ప్రాక్టికల్ వెబ్ ఆధారిత లోతైన అభ్యాసం మరియు భద్రత ఉదాహరణ ద్వారా

Daisyయొక్క ప్రొఫైల్ ఫోటో

ద్వారా Daisy

ప్రాక్టికల్ వెబ్ ఆధారిత లోతైన అభ్యాసం మరియు భద్రత ఉదాహరణ ద్వారా మూడవ ఎడిషన్ షార్లెట్ హార్పర్ జూలై 3, 2024 నవీకరించబడింది/మార్చబడింది జూన్ 3, 2025 ముందుమాట: వెబ్ కోసం సాఫ్ట్‌వేర్‌ను నిర్మించడంలో భద్రతా పరిగణనలు ఏదైనా వెబ్ డెవలపర్ యొక్క ప్రణాళిక మరియు అమలులో ముఖ్యమైన భాగం, అయితే ఒక నమూనాను ఇంజనీరింగ్ చేస్తాయి, ఇది నమ్మదగిన, స్థిరమైన మరియు ఆచరణాత్మక ప్రయోజనాలకు ఉపయోగపడుతుంది. DOM (డాక్యుమెంట్ ఆబ్జెక్ట్ మార్కప్), ఇది HTML, జావాస్క్రిప్ట్ మరియు CSS యొక్క అమలుతో పాటు పైథాన్, సి/సి ++, జావా మరియు బాష్లను అమలు చేసే బ్యాకెండ్ సాఫ్ట్‌వేర్, వెబ్ డెవలపర్‌లకు సృజనాత్మకతను వ్యక్తీకరించే అనేక రకాలైన ప్రాజెక్టులను సృష్టించే స్వేచ్ఛ మరియు శక్తిని ఇస్తుంది, ఉపయోగం యొక్క సౌలభ్యాన్ని మరియు క్యారెక్టర్‌ను అందిస్తుంది, ఇది వినియోగదారు సమయాన్ని చంపడానికి లేదా ఇంటర్నెట్‌లో ఏదైనా చేయటానికి చూస్తున్న వినియోగదారు, సాధారణంగా టచ్‌స్క్రీన్ స్మార్ట్‌ఫోన్ పరికరంలో. చాలా మందికి వారు మొదటి నుండి వెబ్‌సైట్‌ను నిర్మించాలనుకున్నప్పుడు ఎక్కడ ప్రారంభించాలో కూడా తెలియదు, వారు మరొక వ్యక్తి యొక్క వెబ్‌సైట్‌లో ప్రారంభించి, కార్యాచరణ, ఆధారపడటం, ఉపయోగం యొక్క సౌలభ్యం మరియు ముఖ్యంగా సృజనాత్మకతలో పరిమితం చేయబడినదాన్ని నిర్మిస్తారు, వారు అన్ని సరికొత్త శక్తివంతమైన సాధనాలను వారి పారవేయడం వద్ద కలిగి ఉన్నప్పుడు, మరియు ముఖ్యంగా ఖర్చుతో కూడిన డబ్బును ఉపయోగించుకోకుండా, ముఖ్యంగా డబ్బును సమగ్రంగా మార్చడం లేకుండా ఉపయోగపడుతుంది. ఈ పుస్తకం ద్వారా చదవడానికి మరియు నేను మీకు ఏమి నేర్పించాలో తెలుసుకోవడానికి మీకు కొన్ని నిమిషాలు ఉంటే, లేదా మీ లక్ష్యాల గురించి వ్యక్తిగతంగా నాతో మాట్లాడండి మరియు సరైన దిశలో కొంత మార్గదర్శకత్వం పొందండి మరియు మీ స్వంత సాఫ్ట్‌వేర్‌ను కోడ్ చేయడానికి మరియు వ్రాయడానికి నేర్చుకోవటానికి ప్రేరేపించబడితే, ఈ పుస్తకాన్ని ఇంటికి తీసుకెళ్లండి మరియు తదుపరి ప్రభావవంతమైన, శక్తివంతమైన, స్ట్రీమ్లైన్ మరియు ముఖ్యమైన వెబ్ అప్లికేషన్‌ను నిర్మించడానికి కొంత సమయం కేటాయించటానికి మరియు మీ కోసం మీరు ఏమి కోరుకుంటున్నారో మరియు మీ అవసరం. నా గురించి: నేను సి/సి ++, జావా, పైథాన్, హెచ్‌టిఎంఎల్, సిఎస్‌ఎస్ మరియు జావాస్క్రిప్ట్‌లో విస్తృత అనుభవం ఉన్న సాఫ్ట్‌వేర్ డెవలపర్. నేను ప్రజలు ఉపయోగించాలనుకునే వెబ్‌సైట్‌లను నిర్మిస్తాను, సందర్శించాలనుకుంటున్నాను మరియు సమయాన్ని నేర్చుకోవటానికి, పున ate సృష్టి చేయడానికి మరియు చంపడానికి మరియు ముఖ్యంగా, నేను సాఫ్ట్‌వేర్‌ను అమ్ముతున్నాను. వెబ్‌సైట్ ఎలా కనిపించాలని మరియు పనితీరును మీరు ఎలా కోరుకుంటున్నారో మీకు ఒక ఆలోచన ఉంటే, మీరు నాకు మద్దతు ఇవ్వడానికి సిద్ధంగా ఉన్నారు, అందువల్ల నేను మీదే కలుసుకునేటప్పుడు నేను నా స్వంత అవసరాలను తీర్చగలను, మరియు వెబ్‌సైట్‌ను మీరే నడుపుతున్న ఖర్చులను మీరు కవర్ చేయడానికి మీరు సిద్ధంగా ఉన్నారు, నేను మీకు తదుపరి యూట్యూబ్, టిక్టోక్, ట్విట్టర్, గూగుల్ లేదా హైటెక్ భద్రతా అనువర్తనాన్ని మాత్రమే నిర్మిస్తాను. నా సమయాన్ని మీకు విక్రయించడానికి ప్రయత్నించే బదులు, నేను మీదే కొనడానికి ప్రయత్నిస్తున్నాను: ఇప్పటికే ఉన్న సమాచారంతో ఒక అనువర్తనం (వెబ్‌సైట్) ను మీరే నిర్మించటానికి నేను మిమ్మల్ని మాట్లాడాలనుకుంటున్నాను మరియు మీరు స్వతంత్ర సాఫ్ట్‌వేర్ డెవలపర్, వ్యవస్థాపకుడు కావాల్సిన వాటిని మీకు నేర్పుతున్నాను, మీరు కోరుకున్న ఏ రంగంలోనైనా విజయవంతమైన వృత్తిని నడిపిస్తారు. మరియు నాకు స్పష్టంగా చెప్పనివ్వండి, నేను మీకు ఇచ్చే విద్య అనధికారికంగా ఉంటుంది. మీరు పాఠశాలకు వెళ్లి ఇవన్నీ అధికారిక విద్యతో నేర్చుకోవచ్చు, లేదా ఈ పుస్తకాన్ని పాఠశాలలో చదవవచ్చు, మీ పనులను పూర్తి చేయవచ్చు మరియు మీ విద్య నుండి చాలా ఎక్కువ తీసుకోవచ్చు, కాని నేను మిమ్మల్ని అధికారికంగా హాట్ సీట్లో ఉంచను మరియు పనులను పూర్తి చేయమని మిమ్మల్ని అడగను. నేను మీ ప్రొఫెసర్ కాదు, మీ స్వంత వ్యక్తిగత విజయంతో నడిచే కెరీర్ వైపు మీకు మార్గనిర్దేశం చేయాలనుకునే స్నేహితుడిలా మీరు నన్ను ఆలోచించవచ్చు. నేను మీకు విజయాన్ని అమ్మడం లేదు, మీరు మీ సమయంతో కొనుగోలు చేయాలి. కోడ్ నేర్చుకోవడం బాగా నేర్చుకునే వక్రతను కలిగి ఉంది మరియు ఎప్పుడూ సులభం కాదు, లేదా ఉండకూడదు. మీరు మీకు సాధ్యమైనంత కష్టపడి పనిచేయాలి మరియు ప్రయత్నిస్తూ విఫలమై విఫలమై, అనువర్తనాలను మీరే తెలుసుకోవడానికి మరియు నిర్మించడానికి మీరు నిరాశకు గురైనప్పుడు కూడా మళ్లీ ప్రయత్నించండి. అది కోడ్ యొక్క స్వభావంలోనే ఉంది. ప్రోగ్రామర్ దోష సందేశాలను ఇవ్వడానికి రూపొందించబడిన కంపైలర్ చేత కోడ్ నడుస్తుంది మరియు ఇవి మీ సెర్చ్ ఇంజిన్‌లో లోపాన్ని కాపీ చేసి, ఇతరుల ఉదాహరణలను చదివినప్పటికీ, ఇవి మీకు ఎలా కోడ్ చేయాలో నేర్పుతాయి. నేను తప్పక చెప్పాలి, మీరు చాలా గొప్ప, స్మార్ట్, విజయవంతమైన లేదా ఒక అనువర్తనాన్ని రూపొందించడానికి వివరంగా లేదా వివరంగా లేదా వ్యవస్థీకృతంగా ఉండవలసిన అవసరం లేదు. కంప్యూటర్ మీ కోసం ఆ సంస్థను జాగ్రత్తగా చూసుకుంటుంది. మీరు ట్రయల్ మరియు ఎర్రర్ ద్వారా పట్టుదలతో ఉండాలి, దృష్టిని కొనసాగించండి మరియు మీరు చేసే పనులపై కష్టపడి పనిచేయండి మరియు మీరు చేసే పనులన్నింటికీ మీకు చాలా విజయవంతమైన వృత్తి ఉంటుంది. నేను ఎవరు: చివరి విభాగం నేర్చుకోవడం గురించి ఎక్కువ అని నేను గ్రహించాను మరియు ఈ పుస్తకం నుండి మీరు ఒక మార్గాన్ని తీసుకుంటారు. నేను ఖచ్చితంగా ఎవరు? ఇది సంక్లిష్టమైన ప్రశ్న. నేను వైద్య పరిస్థితులతో బాధపడుతున్నందున, ఈ పుస్తకాన్ని కొన్ని సమయాల్లో కోడ్ చేయడం లేదా రాయడం నాకు కష్టతరం చేసేటప్పుడు, సాంఘికీకరణ మరియు గుర్తింపు సమస్యలతో సవాళ్లను ప్రదర్శిస్తూ, నన్ను నన్ను పరిచయం చేసేటప్పుడు నా జీవితాన్ని మరింత కష్టతరం చేసేటప్పుడు నేను అస్పష్టంగా ఉన్నాను. సంక్షిప్తంగా, మీరు ఈ పుస్తకాన్ని చదువుతుంటే, మీరు దానిని ఇంటికి తీసుకువచ్చారు, ఎందుకంటే మీరు దాని ద్వారా తిప్పికొట్టారు మరియు ఇది ఉపయోగకరంగా ఉందని భావించారు, లేదా మీరు ఇంత దూరం చదివినా, మీకు నేను చేసే ప్రతి పనిలోనూ విజయం సాధించాలని కోరుకునే మనస్సు గల వ్యక్తి నేను. నేను ఒకఇంజనీర్ నేనే, సాఫ్ట్‌వేర్ డెవలపర్ మరియు ఒక విద్యార్థి, మరియు సాఫ్ట్‌వేర్ యొక్క హ్యాండ్‌బుక్‌ను సులభతరం చేయాలనుకునే ఇతర విద్యార్థుల కోసం నేను ఈ పుస్తకాన్ని వ్రాస్తున్నాను, వారు తమ జీవితాలను సులభతరం చేయడానికి అవసరమైన సాఫ్ట్‌వేర్ యొక్క హ్యాండ్‌బుక్‌ను కలిగి ఉండటం ద్వారా ఒక పెద్ద పజిల్ లాగా కలిసి పనిచేసే, ఉపయోగకరమైన, పెద్ద, క్రియాత్మక, సమన్వయ మరియు ఆకర్షణీయమైన అనువర్తనం వంటి అనువర్తనాలను కాపీ చేయడం ద్వారా వ్యాపారం యొక్క రేఖతో పాటు విజయం సాధించగలదు. చాలావరకు, నేను చేసేది ఇదే: నాకు మరియు ఇతర వ్యక్తులు విజయవంతం కావడానికి నేను అనువర్తనాలను నిర్మిస్తాను. నేను కూడా రచయితని, ఇది నా పోర్ట్‌ఫోలియోను ఉపయోగకరమైన పత్రంలో ఉంచడానికి నేను పూర్తి చేయాలనుకున్న నా మొదటి ప్రచురణ, మరియు నేను కూడా ఒక కళాకారుడిని. నేను దీన్ని మీకు అంగీకరిస్తాను, నేను ఒక వింత వ్యక్తిని. నేను పరిపూర్ణంగా లేను, కళాశాలలు మరియు విశ్వవిద్యాలయాలను విడిచిపెట్టి, మరింత విజయంతో నా కోసం ఒక పేరు పెట్టడానికి ప్రయత్నించడానికి నేను చట్టంతో నన్ను నడిపాను. నేను పుట్టుకతోనే స్త్రీని, నేను మేకప్ ధరిస్తాను, నా ఫోటోలు తీస్తాను, దుస్తులు మరియు ఇతర మహిళల దుస్తులు ధరిస్తాను, మరియు నేను స్వభావంతో ఆడవారిగా స్పృహలో ఉన్నాను. వెబ్‌అప్‌లను రాయడం మరియు నిర్మించడంలో పోరాటాలకు దారితీసే ఇతర వ్యక్తులతో నాకు గతంలో సమస్యలు ఉన్నాయి, మరియు నేను ఈ పుస్తకాన్ని మీ చేతుల్లో త్వరగా పొందలేకపోయానని క్షమాపణలు కోరుతున్నాను: మీకు ఇది అవసరం. మీరు గనిలాగా కనిపించే మరియు గనిలాగా పనిచేసే కోడ్‌ను చదవాలనుకుంటున్నారు మరియు అదే పని చేస్తుంది, కానీ ఇంకా మంచిది, ఎందుకంటే మీరు మీ కీబోర్డ్‌ను మాష్ చేయడానికి బదులుగా ఈ పుస్తకాన్ని కొనగలిగితే, దాని కోసం డబ్బును అడిగే పుస్తకాన్ని సృష్టించడానికి నేను చేసినట్లుగా, మీ జీవితంలో విజయవంతం కావడానికి మీకు అవసరమైన వనరులు ఉన్నాయి. కుటుంబం పెరగడం, ఆరోగ్య పరిస్థితులు, వైద్యులు, మీడియా మరియు చట్టం తో నాకు అన్ని రకాల సమస్యలు ఉన్నాయి, మరియు నా కోడ్ విభజించబడిన మరియు విసుగు చెందిన ప్రపంచంలో స్త్రీవాదం మరియు స్త్రీ స్వభావం అయిన పోరాటాన్ని లోతుగా ప్రతిబింబిస్తుంది. ఏదేమైనా, ఈ పుస్తకం నేను లోతుగా శ్రద్ధ వహించే విషయం, నా బిడ్డ, నా పోర్ట్‌ఫోలియో మరియు నా జీవనోపాధి, కాబట్టి మీరు వచనాన్ని ఇంటికి తీసుకెళ్ళినప్పుడు మరియు నా నుండి నేర్చుకోవటానికి దానిపై జాగ్రత్తగా రంధ్రం చేసినప్పుడు మీ పరిశీలనను నేను అభినందిస్తున్నాను. దయచేసి నేను పరిపూర్ణంగా లేనని గుర్తుంచుకోండి, ఈ పుస్తకానికి లోపాలు, పునర్విమర్శలు మరియు క్రొత్త సంచికలు ఉంటాయి మరియు నా రచనతో విజయవంతమైన అనుభవాన్ని పొందడానికి మీరు మీ తార్కిక మెదడుతో మీరు చేయగలిగినంత ఉత్తమంగా ఆలోచించాలి. అలాగే, మీరు వ్రాసేటప్పుడు సవాళ్లను ఎదుర్కొన్నప్పుడు కూడా నేను మీకు బాగా అర్థం అని అర్థం చేసుకోండి. దీని గురించి ఇలా ఆలోచించండి: మీరు డిజిటల్ ప్రదేశంలో imagine హించుకోగలిగే ఏదైనా చేయటానికి మీరు కంప్యూటర్ సిస్టమ్‌ను అద్దెకు తీసుకోగలిగినప్పుడు, మీరు ఎదుర్కొంటున్న మొత్తం సమాచారాన్ని నిల్వ చేయండి, విశ్లేషించండి మరియు నిర్వహిస్తారు మరియు అర్థం చేసుకోవడానికి వస్తారు, మీరు తీసుకునే మరియు ప్రచురించే సమాచారంతో మీరు అనివార్యంగా ఇబ్బందులను ఎదుర్కొంటారు. నేను ఈ విషయం చెప్తున్నాను ఎందుకంటే నేను అదే ఇబ్బందులను ఎదుర్కొంటున్నాను. ఈ పుస్తకాన్ని మీ స్వంత ప్రమాదంలో ఉపయోగించుకోండి, సురక్షితమైన సెట్టింగ్‌లో సాఫ్ట్‌వేర్‌ను నిర్మించడానికి మీ సంఘం మరియు సంఘాలతో మీకు అందుబాటులో ఉంది, మరియు మీరు విఫలమైనప్పుడు లేదా తప్పు మార్గంలో విజయవంతం అయినప్పుడు వ్యక్తిగతంగా విషయాలను తీసుకోకండి: అదే నేను ఇంత దూరం ఎలా పొందాను, మరియు నేను మీకు ఈ వచనాన్ని ఎందుకు తీసుకురాగలను మరియు గ్లోబల్ స్కేల్ యొక్క ప్రాముఖ్యతకు గురయ్యేటప్పుడు, ప్రపంచానికి వెళ్ళేటప్పుడు, నేను మీకు ఈ వచనాన్ని ఎందుకు తీసుకువచ్చాను మరియు పిచ్చి యొక్క మార్గాన్ని కలిగి ఉండటానికి మీకు సహాయపడుతుంది. మేము పని చేస్తాము, ఇంటర్నెట్. నేను కొన్ని పదాలతో ఎవరో మీకు బాగా తెలియకపోవచ్చు, కాని నేను మిమ్మల్ని చదవమని ప్రోత్సహిస్తున్నాను, మీ పనిని పూర్తి చేయడానికి మీ స్వంత ప్రాజెక్టులను నిర్మించేటప్పుడు మీరు నన్ను చదవడం మరియు అర్థం చేసుకోవడం కొనసాగిస్తున్నప్పుడు మీరు నన్ను తెలుసుకుంటారు. మీ ప్రొఫెసర్లు లేదా ఉపాధ్యాయులు మీకు ఏదీ కేటాయించనంత కాలం ఈ పుస్తకంతో హోంవర్క్ ఉండదు, కానీ మీరు చదివినప్పుడు ప్రాజెక్టుల పోర్ట్‌ఫోలియోను మీరే నిర్మించమని నేను మిమ్మల్ని బాగా ప్రోత్సహిస్తున్నాను, అలాగే మీరు నేర్చుకున్న వాటిని మీరు ఎలా అన్వయించవచ్చో ప్రదర్శించే క్యాప్‌స్టోన్ ప్రాజెక్ట్. నా క్యాప్స్టోన్ ప్రాజెక్ట్ మీరు ఈ పుస్తకంలో చదివిన వాటిలో చాలా వరకు ఆధారం, ఎందుకంటే ఇది నా మునుపటి ప్రాజెక్టుల నుండి కోడ్‌ను కలిగి ఉంటుంది, నేను సృష్టించిన కోడ్ మరియు చేతితో పద్దతిగా వ్రాయడం నేర్చుకున్నాను, మరియు విస్తృత శ్రేణి ఆలోచనలు మరియు చిట్కాలు నాకు విజయవంతం కావడానికి సహాయపడింది, నేను పూర్తిగా ప్రదర్శించబడే మరియు మీ స్నేహితుడు లేదా కుటుంబాన్ని ఉపయోగించుకోవడాన్ని మీరు చూడగలిగే జనాదరణ పొందిన అనువర్తనం వలె చూసే మరియు ప్రవర్తించే ఒక సాధారణ అనువర్తనాన్ని నేను స్పిన్ చేయగలవు. ఈ పుస్తకం ఏమిటి: ఈ పుస్తకం ఉదాహరణ ద్వారా ట్యుటోరియల్. మీరు ఇక్కడ కోడ్‌ను కనుగొనవచ్చు, కోడ్ ఎలా నేర్చుకోవాలో సూచనలు, కోడ్ డీబగ్గింగ్ మరియు ఫిక్సింగ్ లోపాలను డీబగ్గింగ్ చేయడం, ట్రబుల్షూటింగ్ స్టెప్స్, మీ కోడ్‌ను ఎలా బ్యాకప్ చేయాలి మరియు సేవ్ చేయాలి, ఎవరైనా మీ కోడ్‌ను విచ్ఛిన్నం చేస్తే, మీ కోడ్‌ను భద్రపరచడం, మీ కోడ్‌ను అమలు చేయడం, మీ కోడ్‌ను అమలు చేయడం, నిమగ్నమవ్వడం మరియు మీరు ఒక ఇమేజ్‌కి ప్రాధాన్యతనిస్తే, మీ కోడ్‌ను అమలు చేస్తే, మీ కోడ్‌ను అమలు చేస్తే, మరియు మీరు ఎగతాళిగా ఉన్నారని, ఎందుకు ఉందో, ఎందుకు అని తెలుసుకోవచ్చు. మీ తుది వినియోగదారులకు, మీ వెబ్‌సైట్ సందర్శకులకు సాధ్యమైనంత ఆకర్షణీయంగా ఉండటానికి మీరు సంపూర్ణ ఉత్తమ కాంతిలో నిర్మించిన సాఫ్ట్‌వేర్. ఈ పుస్తకంలో, నేను సాఫ్ట్‌వేర్ డిజైన్ యొక్క అనేక ఉదాహరణలను వెబ్‌లో ప్లాట్‌ఫారమ్‌తో పాటు భద్రతగా ప్రదర్శిస్తాను. మేము అభ్యాసాన్ని ప్రారంభిస్తామురియెన్స్
Praktisk webbaserad djup inlärning och säkerhet med exempel

Kujifunza kwa vitendo kwa kina na usalama kwa mfano Toleo la tatu Charlotte Harper Julai 3, 2024 Imesasishwa/kubadilishwa Juni 3, 2025

Utangulizi:

Mawazo ya usalama katika programu ya ujenzi wa wavuti ni sehemu muhimu ya mpango na utekelezaji wa Wavuti yoyote wakati uhandisi mfano ambao ni wa kutegemewa, thabiti, na muhimu kwa madhumuni ya vitendo. DOM (hati ya maandishi), pamoja na utekelezaji wa HTML, JavaScript, na CSS na pia kurudisha programu ya utekelezaji wa Python, C/C ++, Java na Bash, kuwapa watengenezaji wa wavuti uhuru na nguvu kuunda miradi mingi ambayo inaelezea uundaji, utumiaji wa urahisi na unyenyekevu, na kutoa huduma kwa unyenyekevu na tabia ya unyenyekevu, na ya unyenyekevu ya unyenyekevu na unyenyekevu wa matumizi ya unyenyekevu na unyenyekevu wa unyenyekevu na unyenyekevu wa unyenyekevu na utumiaji wa unyenyekevu na unyenyekevu wa utumiaji wa unyenyekevu na unyenyekevu na utumiaji wa unyenyekevu na utumiaji wa unyenyemu Mtumiaji wa mwisho anayetafuta kuua wakati au kufanya kitu kwenye mtandao, kawaida kwenye kifaa cha smartphone cha skrini. Watu wengi hawangejua hata wapi kuanza wakati wanataka kujenga wavuti kutoka mwanzo, wangeanza kuanza kwenye wavuti ya mtu mwingine na kujenga kitu kidogo katika utendaji, utegemezi, urahisi wa matumizi na haswa ubunifu wakati wangekuwa na zana zote zenye nguvu za hivi karibuni ili kujenga kitu muhimu bila kupoteza vifungo vya kushinikiza wakati, na haswa pesa kulipia pesa kwa sababu ya matumizi ya watu wachache. Ikiwa una dakika chache kusoma kitabu hiki na ujifunze kile ninachotaka kukufundisha, au hata kuzungumza nami kibinafsi juu ya malengo yako na kupata mwongozo katika mwelekeo sahihi, na umehamasishwa kujifunza kuweka nambari na kuandika programu yako mwenyewe, chukua kitabu hiki nyumbani na uweke kando wakati wa kujifunza kufanya nini unachokihitaji kinachotaka.

Kunihusu: Mimi ni msanidi programu na uzoefu anuwai katika C/C ++, Java, Python, HTML, CSS na JavaScript. Ninaunda tovuti ambazo watu wanataka kutumia, wanataka kutembelea, na hata kupata madawa ya kulevya kwa kutumia tu kujifunza, kuunda tena na kuua wakati, na muhimu zaidi, ninauza programu. Ikiwa ulikuwa na wazo la jinsi ulivyotaka wavuti kuangalia na kufanya kazi, ulikuwa tayari kuniunga mkono ili niweze kukidhi mahitaji yangu wakati ninakutana na yako, na uko tayari kufunika gharama za kuendesha tovuti mwenyewe, ningekujengea YouTube inayofuata, Tiktok, Twitter, Google, au hata programu ya usalama wa hali ya juu tu unaweza kupata. Badala ya kujaribu kukuuza wakati wangu, ninajaribu kununua yako: Nataka kuzungumza nawe ili kujenga programu (wavuti) na habari ambayo tayari ipo, na kukufundisha kile unahitaji kuwa msanidi programu wa programu huru, mjasiriamali, akiongoza kazi iliyofanikiwa katika uwanja wowote unaotamani. Acha niwe wazi, elimu ninayokupa itakuwa isiyo rasmi. Unaweza kwenda shuleni na kujifunza haya yote na elimu rasmi, au hata kusoma kitabu hiki shuleni, kukamilisha kazi zako, na kuchukua pesa nyingi kutoka kwa elimu yako, lakini sitakuweka rasmi kwenye kiti cha moto na kukuuliza ukamilishe kazi. Mimi sio profesa wako, unaweza kunifikiria kama rafiki ambaye anataka kukuongoza kwenye kazi inayoendeshwa na mafanikio yako mwenyewe. Na mimi sio kukuuza mafanikio pia, utahitaji kuinunua na wakati wako. Kujifunza kwa kanuni kuna mwinuko wa kujifunza na haukuwa rahisi, au hata unastahili kuwa. Unahitaji kufanya kazi kwa bidii kadri uwezavyo na kuendelea kujaribu na kushindwa na ujaribu tena hata wakati umechanganyikiwa ili kujifunza na kujenga programu mwenyewe. Hiyo ni katika hali ya kanuni yenyewe. Nambari inaendeshwa na mkusanyaji ambayo imeundwa kutoa ujumbe wa makosa ya programu, na hizi zitakufundisha jinsi ya kuweka nambari, hata ikiwa unakili tu kosa kwenye injini yako ya utaftaji na kusoma mifano ya watu wengine. Na lazima niseme, hauitaji kuwa tajiri sana, smart, kufanikiwa, au hata kwa undani ulioelekezwa au kupangwa kujenga programu. Kompyuta inakutunza shirika hilo. Unahitaji tu uvumilivu kupitia jaribio na makosa, kudumisha umakini na kufanya bidii kwa kile unachofanya, na utakuwa na kazi nzuri sana kwa ukamilifu wa kile unachofanya.

Mimi ni nani: Ninagundua kuwa sehemu ya mwisho ilikuwa juu ya kujifunza na kuchukua njia kutoka kwa kitabu hiki. Mimi ni nani haswa? Hilo ni swali ngumu. Sijulikani kwa kuwa mimi mwenyewe, kwani ninaugua hali ya matibabu ambayo inaweza kufanya kuwa ngumu kwangu hata kuweka kanuni au kuandika kitabu hiki wakati mwingine, wakati nikitoa changamoto na ujamaa na maswala ya kitambulisho ambayo hufanya maisha yangu kuwa magumu zaidi linapokuja suala la kujitambulisha. Kwa kifupi, ikiwa unasoma kitabu hiki, ulileta nyumbani kwa sababu ulipitia na ulidhani ilikuwa muhimu, au hata ikiwa unasoma tu hivi, kwako mimi ni mtu kama mtu ambaye anataka kukuona unafanikiwa katika kila kitu unachofanya. Mimi ni mhandisi mwenyewe, msanidi programu, na mwanafunzi, na ninaandika kitabu hiki kwa wanafunzi wengine ambao wanataka kufanya maisha yao iwe rahisi kwa kuwa na kitabu cha programu wanachohitaji kufanya maisha yao iwe rahisi kwa kutoa mifano ya kunakili ambayo inafaa pamoja kama puzzle kubwa kuwa kazi, muhimu, kubwa, kazi, kushikamana, na programu ya kushirikisha ambayo inaweza kufanikiwa bila kujali biashara ya biashara. Kwa kiasi kikubwa, hii ndio ninafanya: Ninaunda programu za kujisaidia na watu wengine kufanikiwa. Mimi ni mwandishi pia, ingawa hii ni uchapishaji wangu wa kwanza ambao ninakusudia kukamilisha ili kuweka jalada langu pamoja kwenye hati muhimu, na mimi pia ni msanii. Nitakubali hii kwako, mimi ni mtu wa kushangaza. Mimi sio kamili, nimekuwa nikiendesha INS na sheria hata ikiniongoza kuacha vyuo na vyuo vikuu na kuacha majimbo ili kujaribu kujipatia jina na mafanikio zaidi. Mimi ni mwanamke kwa kuzaliwa, mimi huvaa mapambo, kuchukua picha zangu, kuvaa nguo na mavazi mengine ya wanawake, na mimi hujitambua kama mwanamke kwa asili. Nimekuwa na maswala na watu wengine hapo zamani ambayo husababisha mapambano na kuandika na kujenga wavuti, na ninaomba msamaha kwamba sijaweza kupata kitabu hiki mikononi mwako mapema: ulihitaji hii. Utataka kusoma na kuandika msimbo ambao unaonekana kama wangu na unafanya kazi kama yangu na hufanya kitu kile kile lakini bora zaidi, kwa sababu ikiwa unaweza kumudu kununua kitabu hiki badala ya kuweka kibodi yako kama mimi hufanya tu kuunda kitabu mwenyewe ukiuliza pesa, una rasilimali unayohitaji kufanikiwa katika maisha yako. Nilikuwa na kila aina ya maswala na familia inakua, hali ya kiafya, madaktari, vyombo vya habari, na sheria, na kanuni yangu inaonyesha sana mapambano ambayo ni wanawake na asili ya kike katika ulimwengu uliogawanyika na uliochanganyikiwa. Walakini, kitabu hiki ni kitu ambacho ninajali sana, mtoto wangu, kwingineko yangu, na maisha yangu, kwa hivyo ninashukuru kuzingatia kwako wakati unachukua maandishi nyumbani na kwa uangalifu juu yake ili ujifunze kutoka kwangu. Tafadhali kumbuka mimi sio kamili, kitabu hiki kitakuwa na makosa, marekebisho, na matoleo mapya, na utahitaji kufikiria na ubongo wako wa kimantiki kadri uwezavyo ili uwe na uzoefu mzuri na uandishi wangu. Pia, elewa kuwa ninamaanisha vizuri kwako hata unapokabiliwa na changamoto wakati wa kuandika. Fikiria juu yake kama hii: Wakati unaweza tu kukodisha mfumo wa kompyuta kufanya kitu chochote unachoweza kufikiria katika nafasi ya dijiti, kuhifadhi habari yote unayokutana nayo, kuchambua na kuipanga, na uielewe, utakutana na shida na habari unayoingiza na hata kuchapisha. Ninakuambia hii kwa sababu ninakutana na shida zile zile. Tumia programu hii kwa hatari yako mwenyewe, fanya kazi na jamii yako na jamii zinazopatikana kwako kujenga programu ndani ya mpangilio salama, na usichukue vitu vya kibinafsi wakati unashindwa au hata kufanikiwa kwa njia mbaya: ndivyo nilivyofika sasa, na kwa nini ninaweza kukuletea maandishi haya na kukusaidia kwa njia ya kawaida ya kila mtu kwa sababu ya kila mtu kwa sababu ya kila mtu kwa sababu ya kila mtu kwa sababu ya kila mtu kwa sababu ya kila mtu kwa sababu ya kila mtu kwa njia ya global on the on the on the of the wazimu ambayo inaniacha kuharibiwa, kung'olewa na kudharau wakati mimi hukutana na kila mtu kwa njia ya global on the the global scale on the the global scen the global on the the global on the the global on the the global scale on the global on the the global on the the global global the global the global the global invloen the global in the global in the global invloen the global invloen the global the Netwont itafanya kazi, mtandao. Labda hauwezi kufahamiana sana na mimi ni nani na maneno machache tu, lakini ninakutia moyo usome, utanijua unapoendelea kusoma na kunielewa wakati wa kujenga miradi yako mwenyewe kukamilisha kazi yako. Hakutakuwa na kazi ya nyumbani na kitabu hiki, kwa muda mrefu kama maprofesa wako au waalimu hawakupei yoyote, lakini ninakutia moyo sana kujenga kwingineko ya miradi mwenyewe unaposoma pamoja, na vile vile mradi wa capstone unaonyesha jinsi unavyoweza kutumia kile umejifunza. Mradi wangu wa jiwe ni msingi wa mengi ya yale utakayosoma katika kitabu hiki, kwani inajumuisha nambari kutoka kwa miradi yangu ya zamani, nambari ambayo nimeunda na kujifunza kuandika kwa mikono kwa mkono, na maoni anuwai na vidokezo ambavyo vimenisaidia kufanikiwa kufikia mahali ambapo naweza kutumia programu rahisi ambayo imeonekana kabisa na inaonekana na tabia kama programu inayoweza kuona kuwa na rafiki yako, kwa mtandao, kwa mtandao, au kutangaza kwa mtandao, au kutangaza, au kutangaza kwa familia yako, au kutangaza, au kutangaza kwa familia yako, au kutangaza, au kutangaza kwa familia yako, au kutangaza, au kutangaza kwa familia yako, na familia, au kutangaza wewe kwa kweli, au kutangaza kwa familia yako, au kutangaza kwa familia yako, kwa familia, au kutangaza kwa familia yako au kutangaza kwa familia, kutangaza wewe au familia kwa familia, wiki

Kitabu hiki ni nini: Kitabu hiki ni mafunzo kwa mfano. Unaweza kupata msimbo hapa, maagizo ya jinsi ya kujifunza kuweka nambari, habari juu ya nambari ya kurekebisha na kurekebisha makosa, hatua za kutatua, maagizo juu ya jinsi ya kuhifadhi na kuhifadhi nambari yako, kupeleka tena ikiwa mtu yeyote atavunja nambari yako, salama nambari yako, upeleke nambari yako, ujenge, ni kwa nini ni kwa sababu hii ni kwa sababu hii ni kwa sababu hii ni muhimu, kwa sababu hii ni nini, ni kwa nini ni kwa nini ni kwa nini ni kwa sababu hii ni muhimu, ni kwa nini ni kwa nini ni kwa nini ni kwa nini ni kwa nini ni kwa nini ni kwa nini ni kwa nini, ni kwa nini ni kwa nini ni kwa nini, ni kwa nini ni kwanini mimi, kwa nini ni kwanini mimi, kwa nini mimi, ni kwa nini mimi, ni kwa nini mimi, mimi ni kwanini, mimi ni nani, mimi ni kwanini mimi, mimi ni nani, mimi ni nani, mimi ni kwanini mimi, mimi ni kwanini mimi, mimi ni nani, mimi ni kwanini mimi, mimi ni nani, mimi ni nani, mimi ni nani, mimi ni nani, mimi ni nani, mimi ni nani, na mimi ni mpango, Programu unayoijenga katika nuru bora kabisa kuwa ya kuvutia zaidi iwezekanavyo kwa watumiaji wako wa mwisho, wageni wa wavuti yako. Katika kitabu hiki, nitaonyesha mifano kadhaa ya muundo wa programu kwa kuzingatia wavuti kama jukwaa na usalama. Tutaanzisha uzoefu wa kujifunza kwa kujenga mradi wa kimsingi kwa kutumia ganda la Unix, na nakala rudufu na maandishi. Halafu, tutachunguza wavuti ya msingi ya blogi, sasisha blogi yetu na huduma za picha na video na pia tumia huduma hizi kutumia suluhisho za usalama kwa kutumia programu ya bure, na salama seva yetu kwa kutumia moduli ya uthibitishaji ya Pluggable (PAM). Kisha tutakagua utunzaji wa faili na usindikaji, kuchunguza uhariri wa video, mchango wa sauti, skanning ya barcode na utambuzi wa tabia ya macho, kati ya dhana zingine. Njiani tutachunguza API ambazo zitatusaidia kufanya programu yetu kuwa muhimu zaidi na salama, na chaguzi za bure na zilizolipwa. Njiani, tutachunguza zana za usalama wa mwili na wanamgambo kama vile silaha za moto na muundo wa utengenezaji na utengenezaji ikiwa ni pamoja na pipa na muundo wa kurudisha, turret na muundo wa drone, na wakuu wengine tutaunganisha na programu yetu kwenye mtandao uliopo ili kulinda programu yetu na kuonyesha kujitetea na ustadi. Tutachukua mapumziko njiani kujenga michezo, 2D na 3D kutoa injini, na kufanya kazi na vifaa vilivyoingia katika kesi za uchunguzi wa programu za msingi za kutoa na programu ya elektroniki inayoweza kutetemeka katika mpira wa silicone mtawaliwa. Njiani, pia tutaajiri suluhisho za kujifunza mashine tayari zinapatikana ili kupata bora programu yetu. Pia tutaajiri zana za hisa zinazopatikana kwa wavuti ili kuelekeza na kupata mchakato. Kitabu hiki ni mwongozo wa mafanikio yako katika kujenga programu ya wavuti na kuiunganisha na mtandao wa kitaalam wa kompyuta na mifumo iliyoingia ya mitambo, na kwa jumla mwongozo wa programu ya ujenzi na vifaa vilivyoingia bila maarifa ya nyuma au uzoefu uliopita.

Kitabu hiki sio nini: Ikiwa unataka kweli kuwa na wavuti, unaweza tu kuanzisha duka rahisi na kuuza kile unachohitaji, chapisha blogi, chapisha picha au video, au vinginevyo bila kuandika safu moja ya nambari. Kitabu hiki sio hivyo. Kitabu hiki kitakufundisha jinsi ya kujenga programu ambayo ni muhimu zaidi, iliyoonyeshwa kikamilifu, inafanya kazi na salama kuliko programu yoyote unayoweza kupata, kwa sababu inapeleka programu ya hivi karibuni ambayo bado ni prototypes, inaweza kuwa ghali kuendesha kwa kiwango kikubwa kampuni za wazee zinafanya kazi, na haitoi rufaa kwa kurudi nyuma, kampuni zilizosababishwa na kuanzisha pesa kwa watu ambao hawafanyi chochote. Ukifuata kitabu hiki kwa karibu, utataka kuandika msimbo, nambari ya utafiti, jenga programu zako mwenyewe, na utapata pesa kutoka kwa kile unachofanya. Nitatoa pesa kutoka kwa kitabu hiki, hata katika hatua za mwanzo, kwa sababu ina habari ambayo watu wanahitaji na wanataka kusoma, na tayari wananunua wakati wananunua au kutumia programu zangu. Kitabu hiki hakitakujengea programu, lakini itakuelekeza katika mwelekeo sahihi na kukupa vifaa unavyohitaji na ustadi na vidokezo ambavyo vitawezesha mafanikio yako mwenyewe katika ujenzi wa programu ya wavuti, na kila mstari wa nambari utahitaji kuandika kama mfano, tayari kugawanywa pamoja kwenye programu yako na wafuasi wako, wageni, wateja, marafiki, familia, wageni, na watu wanaotaka.

Nini utajifunza: Kitabu hiki kitakufundisha jinsi ya kujenga na kuuza programu, kazi ya kweli, programu muhimu, kurekodi media, huduma za usalama kama utambuzi wa usoni, skanning ya eneo la barcode inayoweza kusomeka, API za wavuti kudhibitisha, kurekodi na kutoa video na picha, na ubadilishe ujumbe kama mawasiliano ya Bluetooth na karibu na Field (NFC). This book will teach you how to use a networked computer, focusing on debian linux, how to build bash code to make installing and backing up your software a seamless, automated breeze, how to build python code as a backend to serve dynamic messages, style things nicely using CSS styles with Bootstrap, enable user logins and interactivity through networked devices, build interactive media and network with other websites to offer security features like text Ujumbe wa uthibitisho au madhumuni mengine, skanning ya kitambulisho, picha na video, microtransaction ya data kuweka programu yako salama, usindikaji wa malipo, biashara ya cryptocurrency, kazi za asynchronous, na zaidi. Utajifunza jinsi ya kujenga vifaa vyako vya Bluetooth, na betri, chaja, viboreshaji, mizunguko, motors na sensorer, kwa kutumia solder, waya na 3D iliyochapishwa pamoja na vifaa vya kutupwa. Nitaonyesha wakuu wa muundo wa 3D waliotumika kwa utengenezaji wa nyongeza na zana na kutengeneza kufa, kwa hivyo una uwezo wa kutengeneza vifaa vyako vilivyoingia, vifaa vya vifaa vilivyo na betri zilizojumuishwa, chaja, mizunguko ya elektroniki, na matokeo ya kazi. na uwape mtandao na Bluetooth na Wavuti. Hasa, tutachunguza masomo mawili ya kesi, massager ya kutetemeka na silaha ya moto ya nyumbani, zote mbili zilizopangwa katika OpenSCAD, ambayo inapatikana kama interface ya picha au matumizi ya mstari wa amri na inaweza kuunganishwa kwenye wavuti kwa matokeo ya haraka. Utajifunza jinsi ya kujenga na kupeleka wavuti kutoka ardhini hadi bila uzoefu wa hapo awali, kuifanya iwe kazi, salama, nzuri, muhimu na muhimu zaidi kwa vitendo. Utajifunza jinsi ya kutumia kujifunza kwa mashine na maono ya kompyuta kufanya tovuti iwe salama na ya vitendo zaidi, rekodi video na sauti kutoka kwa wavuti yako, toa sauti yako, fanya muziki na ubadilishe sauti kuunda sampuli muhimu, na jinsi ya kuvunja kelele kwa kueneza tovuti zingine ili kujenga mtandao bora wa wavuti ambazo unaweza kuunganisha moja kwa moja ili kushiriki habari yako na habari muhimu zaidi. Kitabu hiki kitaelekezwa sana kwenye media, usalama na kujifunza mashine, ambazo ni sehemu kuu tatu ambazo zitakusaidia kujenga programu muhimu kwa Wavuti kwa kuwashirikisha watumiaji sahihi na kuwaondoa wale wasiofaa kwa njia ambayo ni ya kweli, ya vitendo, mikono na inayohusika wakati pia ni moja kwa moja, na ngumu. Kitabu hiki kinafundisha Unix, haswa Debian (Ubuntu), Bash Shell, Python, HTML, CSS, JavaScript, na vifurushi kadhaa vya programu muhimu kwa Python kama maombi, na programu muhimu ya bash kama GIT na FFMPEG. Pia nitakufundisha jinsi ya kuuza cryptocurrency moja kwa moja, na kuchukua malipo katika cryptocurrency au kutoka kadi za kawaida za malipo wakati hata unalipa wageni wako sehemu ya mapato yako ikiwa utachagua kufanya hivyo. Nitakufundisha jinsi ya kupata pesa kutoka kwa wavuti yako kupitia matangazo pia, jinsi ya kutayarisha programu yako kwa injini za utaftaji na kuifanya iwe haraka, iliyoorodheshwa katika nafasi ya kwanza kwa kile wateja wako watatafuta kukupata, na kuweka nafasi katika utaftaji wa kawaida iwezekanavyo. Nitakufundisha jinsi ya kuuza programu yako, kuitangaza, rufaa kwa wateja wanaotafuta huduma zako, na ujipatie jina kwenye mtandao kupitia njia ambazo tayari zipo, hazina bei ghali, na hufanya kazi vizuri. Nitakufundisha jinsi ya kuokoa data yako kwenye kompyuta za wingu ambazo zinakufanyia kazi na uhifadhi data yako kwa bei rahisi, jinsi ya kupanga na kujenga wavuti ambayo hufanya kile watumiaji wako wanataka na kile unachotaka, na jinsi ya kuweka watumiaji wako wanaohusika kwa kuweka tovuti yako bomba kwenye simu zao na arifa, barua pepe, ujumbe wa maandishi, simu za simu, na njia zaidi ili kuwarudisha watumiaji wako kwenye wavuti yako kwenye kitufe cha kubonyeza kwa kubonyeza kwa kitufe cha kubonyeza. Kitabu hiki kitazingatia umuhimu wa kuchapisha na kusambaza vyombo vya habari kwa kiwango kikubwa, kutoka kwa maandishi hadi picha hadi video hadi sauti, na kufanya hisia nzuri kwa watumiaji wa mwisho (mteja wako), na kujiuza kwa njia yoyote unayofanya ili kuunda wavuti, programu ambayo ni mwakilishi wako na wewe tu, na inakufanya, programu yako na kampuni yako ionekane vizuri kwa njia bora. Pia utajifunza vidokezo vichache na hila kutoka kwangu, kutoka kwa vidokezo vya kuweka alama, ubatili wa vitendo kama mapambo na upigaji picha, kuiga na kuigiza, na zaidi, ambayo itakuwa muhimu kwa kujionyesha na kampuni yako kwa taa bora kwa kutumia zana zote zinazopatikana wakati wa kusambaza bidhaa nyingi kama vile unahitaji katika usawa mzuri wa majukwaa ili kuleta programu yako kwa kuzaa bila juhudi, au kufanya kazi. Kitabu hiki kinaitwa "VitendoKujifunza kwa kina na Usalama kwa mfano "Kwa sababu: Inashughulika na kujifunza kwa kanuni, haswa kwa wavuti, haswa kwa kuzingatia usalama, kutoka kwa mtazamo wa vitendo, na mifano ya nambari ya kufanya kazi ambayo hutumikia madhumuni ya vitendo ilivyoainishwa katika maandishi. Sehemu ya kujifunza ya maandishi haya, inajumuisha Mashine ya Kujifunza, nambari nitakuonyesha jinsi ya kukimbia kwa picha ya wavuti, picha ya kutambulika, picha ya kutambulisha, picha ya kutambulika, picha ya kutambulika, picha ya kutambulika, picha ya kutambulika, picha ya kutambulika, kutambulika kwa picha, kutambulika kwa picha, kutambulisha kwa picha, kusuluhisha picha, kutambulika kwa picha, kusuluhisha picha, kutambulisha kwa picha, kushughulikia picha, kuhitaji kutambulika kwa picha, kushughulikia kwa picha ya kushughulikia misulino, kuhitaji kushughulikiwa, kuhitaji kushughulika na VICEUT. Uboreshaji, maelezo ya picha, na kazi zingine kama metriki za utabiri kutoka kwa picha, kama vile asili ya picha kama picha halisi, iliyohamishwa kwa kompyuta, au nakala ya macho (picha ya picha, au picha iliyochapishwa). Wewe na uso wako. unatumia). Mtu yeyote ambaye huunda programu ambayo iko salama kabisa ana maoni fulani ya nini hii inamaanisha. Programu haina usalama wa asili kwa sababu vifaa na akaunti tunazotumia kuipata sio wakati wote, zinaweza kuwa mikononi mwa mtu yeyote aliye na nia mbaya ya programu hiyo na kwa hivyo inaweza kuwa hatari kwa programu yenyewe. Hili ni kitu cha kuzingatia kitabu hiki. Kompyuta iliyo na mtandao imehifadhiwa na ishara ya ufunguo mrefu, inayoitwa na SSH au salama ya ganda, na vinginevyo ni bora na seva ya wavuti, kwa sababu seva ya wavuti hutoa ufikiaji wazi na hali ya zana za usalama wa sanaa zinazoendesha kwenye seva yenyewe. Seva ya wavuti ina ufikiaji wa kivinjari cha Wavuti cha Watumiaji, ambayo ni sehemu yenye nguvu zaidi ya kifaa cha mtumiaji, kwa sababu ndio mahali ambapo mtumiaji anaweza kupata programu ya mtandao. This toolkit can render text, the webpages you see, and can also record images, audio and video (like a photo of a face or a state ID), can read and write to Bluetooth radio devices, and can read and write to near field transponder tags, inexpensive key cards, fobs, stickers, rings and even chip implants with unique serial numbers that can be read and written to with data generated and validated by a web server tied to the web tovuti. Kutumia zana zote unazo, na kitabu hiki utajipatia maarifa ya kujenga wavuti salama, na kwa jumla mfumo salama wa kompyuta ambao unakufanyia kazi, je! Zabuni yako, na inaonekana na unahisi

Wapi kuanza: Unakaribishwa kuruka nyuma ya sehemu ninayoanza kitabu hiki na, au sehemu yoyote, kwa nambari halisi unayohitaji, haswa ikiwa una uzoefu wa kuweka coding kabla au zana yoyote iliyotajwa hapo awali ambayo nitakuwa nikielezea kwa undani katika kitabu hiki na vile vile kumbukumbu za matumizi na mifano ya vitendo. Ikiwa hauna uzoefu katika nambari ya uandishi, napendekeza sana usome kitabu hiki, na unapendekeza usome sehemu zilizopita, ili kuhakikisha kuwa kitabu hiki ni sawa kwako. Ikiwa kitabu hiki sio sawa kwako, fikiria kuipatia rafiki au jamaa ambaye anaweza kuwa na hamu ya kujifunza juu ya maendeleo ya wavuti wenyewe, na hata kufikiria kukopa tena na kujifunza kutoka kwao kujaza mapengo ambayo nilishindwa wewe kama mwalimu, au waalimu wengine walifanya kabla yangu. Anza ambapo utakavyofanya, kila sehemu ya kitabu hiki itakuwa muhimu ikiwa unakusudia kujenga programu muhimu, na uzingatia kuwa programu bora zimejengwa na mtumiaji wa mwisho akilini: Jua mteja wako. Sasa unanijua, unajua kitabu hiki, na uko tayari kuanza. Kuanza, kunyakua kompyuta (hata kompyuta ndogo ya bei rahisi kutoka duka la sanduku, Amazon, au desktop ya zamani, na kuiweka kwa njia inayokufanyia kazi.

Jinsi ya kusoma kitabu hiki: Maandishi yalionyesha, inaashiria kuwa maandishi ni ya haraka ya amri, ambapo utaandika nambari unayoendesha. Haraka ya amri imezingatia sana kibodi na inahitaji kidogo kubonyeza, kuharakisha utiririshaji wako wa kazi na kufanya mambo iwe rahisi kwako.

Kuanza: Wacha tuingie. Tutaanza kwa kujenga nambari kwenye mashine ya ndani na tuanze bila kujenga tovuti iliyounganishwa na mtandao. Hii ni salama kuanza na, haitoi chochote, na ni rahisi kwako. Kulingana na mfumo wako wa kufanya kazi, kuingia kwenye ganda la bash itakuwa tofauti kidogo. Kwa Mac OS, ninapendekeza kusanikisha mashine ya kawaida wakati huu, kwani utapata utangamano zaidi na mashine ya kawaida. Watoa huduma mbali mbali kama VirtualBox na Paralell wanaweza kukutengenezea mashine, ingawa inawezekana pia kusanikisha Ubuntu moja kwa moja kwenye mashine, ikiwa unapendelea kutumia mazingira ya asili ambayo inashauriwa ili kuunda uzoefu wa haraka na ulioratibiwa. Ikiwa unatumia Linux au Windows, ambayo ninapendekeza, inapaswa kuwa rahisi kuunda mradi. Fungua terminal yako, rekebisha ukubwa kama unavyoona inafaa, na anza kufuata hatua ya 2. Ikiwa unatumia Windows, tafadhali fuata hatua ya 1.

Hatua ya 1: - Watumiaji wa Windows tu Katika Windows, fungua amri ya haraka kama msimamizi na aina WSL -Install

Hatua ya 2: - Endelea hapa, au ruka hatua ya 1 hapa ikiwa hautumii Windows Katika terminal wazi, (kulingana na OS yako, inayoitwa Ubuntu katika Windows, terminal katika Mac au Linux, au jina linalofanana), anza kwa kuunda mradi. Tunafanya hivyo na amri ya mkdir, ambayo huunda saraka. Ikiwa unahitaji kuunda saraka ya kuhifadhi mradi wako, ambao unapendekezwa, tumia amri ya CD kubadilika kuwa saraka na

CD/njia/kwa/saraka - Njia ni folda (faili) ambazo hutangulia saraka yako ya marudio, njia yako ya msingi ni ~ au/nyumbani/jina la mtumiaji (ambapo jina la mtumiaji ni jina lako la mtumiaji). Ili kubadilisha kwenye saraka ya chaguo -msingi, chapa CD au CD ~ Mfano wa Mkdir - Badilisha "Mfano" na jina la saraka

Sasa unayo saraka ya kufanya kazi kwa mradi wako. Kwa kuwa ni muhimu sana kuwa na saraka hii iliyohifadhiwa ikiwa unahitaji kubadili mashine tofauti au kupeleka nambari unayoandika kwa hivyo iko tayari kwa wavuti, tutaunda hati ya kuhifadhi saraka yako katika hatua chache zijazo. Lakini kujenga hati inachukua nambari kidogo, na nambari inahitaji kujiendesha ili kuwa muhimu iwezekanavyo. Basi wacha tujenge maandishi ya kujenga maandishi kwanza. Wacha tuanze kwa kuunda maandishi na kuifanya iweze kutekelezwa. Tutatumia sudo, chmod na kugusa kwa hii, na kupiga hati "Ascript".

Sudo Touch/usr/bin/ASCRIPT Sudo chmod A+x/usr/bin/ascript Sudo Nano/usr/bin/Ascript

Sasa tumeunda maandishi, kuifanya iweze kutekelezwa, na tuko tayari kuibadilisha. Nano ni mhariri wa maandishi ambayo itakuruhusu kuhariri maandishi bila kubonyeza, ambayo ni rahisi sana kuliko kutumia interface ya mtumiaji wa picha. Ili kuhariri faili na Nano, tumia Nano na kisha njia ya faili. Ili kutengeneza maandishi ambayo hufanya hati, ni sawa na kutengeneza hati yetu kwanza. Tutatumia nambari ile ile kama hapo juu, ikibadilisha jina la hati, "Ascript" na paramu ya hoja, $ 1. Hii inaturuhusu kupiga simu kwa kuandika maandishi ya habari ya Sudo Ascript, wakati ambao tunaweza kuunda hati yoyote mpya kwa kubadilisha "Newscript" na jina la hati yako. Nambari katika Nano inapaswa kuonekana kama:

Sudo Touch/usr/bin/$ 1 Sudo chmod A+x/usr/bin/$ 1 Sudo Nano/usr/bin/$ 1

Na kufunga Nano, tunaweza kushikilia kitufe cha kudhibiti na bonyeza X, kisha y kuashiria tunaokoa faili, na tunarudi. Sasa badala ya kuandika amri hizi tatu kuhariri hati, tutaweza kuandika maandishi ya Sudo ili kuhariri hati tena. Hii inafanya kazi! Na hati yoyote mpya inaweza kuendeshwa kwa urahisi kwa kuiita kwenye ganda. Wacha tuhifadhi kazi yetu sasa: Wacha tuandike hati ya chelezo ili kuokoa hati yetu mpya na kisha tuirudishe kwenye saraka yetu ya mradi, wakati pia tunahifadhi hati ya nakala rudufu.

Backup ya Sudo Ascript

Sasa, katika Nano:

sudo cp/usr/bin/chelezo/njia/kwa/saraka/ sudo cp/usr/bin/ascript/njia/kwa/saraka/

Ambapo/njia/kwa/saraka ndio njia ya mradi uliounda na MKDIR. Baadaye tutajifunza jinsi ya kunakili njia za kurudia kama hii na kitanzi na orodha, ambayo ni nambari kidogo, lakini kwa sasa wacha iwe rahisi na tuwe na mistari michache. Ili kuendesha hati hii na chelezo nambari yako, uhifadhi faili katika nano na udhibiti+x, y na urudi, na chapa hapa chini kwenye ganda lako

chelezo

Ikiwa unaongozwa kabisa kwa nywila wakati unasoma kitabu hiki na kufuata pamoja kwenye ganda, tafadhali ingiza nywila yako ya mtumiaji kwa usahihi, utakuwa na majaribio matatu kabla ya kuhitaji tena amri. Unaweza kutumia mishale ya juu na chini kurudisha amri na kuzibadilisha, ikiwa unahitaji kuendesha chochote mara mbili. Bonyeza rahisi na chini mara kwa mara kuchagua amri, kabla ya kuhariri amri na mishale ya kulia, kushoto na futa kitufe na kibodi, na uiendeshe kwa kurudi.

Hongera! Uliweza kuunda hati ya kushangaza ya chelezo ambayo inarudisha maandishi mawili muhimu ya ganda kwenye saraka yako ya kufanya kazi. Tunaweza kuzunguka mambo baadaye wakati mradi unakua mkubwa, lakini hii inafanya kazi kwa sasa. Wacha tuendelee kuunga mkono wingu, tutatumia GitHub kwa hii (ingawa kuna suluhisho zingine nyingi za GIT kwa nakala rudufu, zote ziko sawa.) Git ni programu ya kudhibiti ukweli ambayo hukuruhusu kurudisha nyuma programu yako kama unavyofanya kwa seva, wakati pia inakuwezesha kupakua nakala zote za programu yako nyuma ya nywila au ufunguo. Ni muhimu katika kuokoa programu yako, haswa tunapohamia kwenye visa vya Linux ambavyo wakati mwingine huvunja wakati mstari mmoja wa nambari unashindwa, na kukuacha umefungwa wakati nambari yako inaweza kuwa haijarudishwa ikiwa hautapata nafasi ya kuiunga mkono moja kwa moja, ambayo tutashughulikia.

Ikiwa haujatumia Mashine ya Ubuntu Virtual wakati huu, ninarudia kutumia mashine ya Ubuntu Virtual kwa wakati huu kwa sababu itafanya maisha yako iwe rahisi wakati wa kusanikisha vifurushi vyote muhimu ili kujenga wavuti ya kufanya kazi na kuandaa shughuli za kujifunza kwa kina kwenye kompyuta yako. Tutahamisha nambari hiyo kwa seva ya wavuti katika siku za usoni, lakini tunataka kuhakikisha kuwa kuna angalau tabaka chache za usalama nyuma ya seva yetu ya wavuti ambayo ni sugu kwa ulaghai, na kuajiri vifurushi kadhaa vya Linux ili kufanya hivyo. Ikiwa bado unataka kutumia Mac OS, unakaribishwa kutafuta na kusanikisha vifurushi muhimu mkondoni, lakini kunaweza kuwa hakuna njia mbadala kwa kila kifurushi kitabu hiki au safu hii itashughulikia.

Wacha tuongeze amri chache kufanya kazi yetu na hati ya chelezo kwa kuendesha nakala rudufu ya Amri Sudo Ascript.

#… Git Ongeza -Lema Git ahadi -m "Backup" git kushinikiza -u asili ya bwana

Kama

Kwa mara nyingine tena, dhibiti X ili kuokoa.
sudo touch /usr/bin/ascript
sudo chmod a+x /usr/bin/ascript
sudo nano /usr/bin/ascript
Sasa tunahitaji kufanya usanidi wa wakati mmoja kwa mradi huu. Kwa sababu hivi karibuni itakuwa mradi wa GIT, hatuitaji kuandika kila amri kila wakati tunapopeleka kutoka kwa hazina ya git, lakini tutapata hang ya hii wakati tunaandika maandishi yetu ya kupelekwa. Kuanza, wacha tuhakikishe tuko kwenye saraka sahihi na uanzishe hazina ya GIT na tutoe funguo za SSH.

CD/njia/kwa/saraka git init tawi la git -m bwana SSH-Keygen

Baada ya kuandika SSH-Keygen, kitufe kipya kinapaswa kuokolewa kwenye folda ya nyumbani chini ya folda inayoitwa .SSH. Inaitwa id_rsa.pub. Wacha tupate ufunguo huu na uinakili. Kuiona,
sudo touch /usr/bin/$1
sudo chmod a+x /usr/bin/$1
sudo nano /usr/bin/$1
CD ~ paka .ssh/id_rsa.pub

Nakili maandishi ambayo yamerejeshwa na amri ya mwisho, na uunda akaunti na mtoaji wako wa GIT (haswa GitHub), kabla ya kuongeza kitufe cha SSH kwenye akaunti yako. Mara tu ukiwa na akaunti, bonyeza menyu ya juu ya kulia na ingiza Mipangilio, kabla ya kuongeza kitufe chako cha SSH katika funguo za SSH na GPG chini ya ufikiaji kwenye menyu. Chagua Ongeza kitufe cha SSH na ongeza yako kwa kuibandika ndani na kuipatia kichwa, kabla ya kuokoa na kurudi GitHub kuunda hazina mpya. Hii ni sawa kwa watoa huduma wengine wa GIT, utahitaji kusoma nyaraka zao. Katika usanidi mpya wa hazina, toa kumbukumbu yako jina linaloelezea na uamue ikiwa unataka kuchapisha, na hakikisha usisanidi faili za kuingizwa bado. Mara tu kumbukumbu imeundwa, nakili Clone na SSH URL, na ubandike kwa amri ifuatayo.

Git kijijini ongeza git: //… (url yako ya mbali)
sudo ascript backup
Sasa unaweza kurudi kwenye hazina yako na CD, utajua hii. Jaribu hati yako ya chelezo sasa na chelezo

Kubwa! Sasa tunaweza kupata coding. Wacha tuweke Django sasa kwa kuwa tunaelewa vizuri juu ya bash na git. Django ataturuhusu tuunga mkono programu yetu moja kwa moja, Bash anaweza kufanya hivyo pia lakini Django inapaswa kuwa na utekelezaji rahisi (inaweza kulemazwa na kusanidiwa kwa urahisi zaidi).

Ili kusanikisha programu katika Ubuntu, tutatumia amri ya sudo apt-kupata. Kwanza, wacha tusasishe na kuboresha programu ambayo tayari tulikuwa nayo. Hii inaweza kufanywa na sasisho la sudo apt-kupata na sudo apt-kupata sasisho -y. Ifuatayo, wacha tuweke Python na mazingira yetu ya kawaida, nyumba ya nambari yetu, na amri ifuatayo: sudo apt-Get kufunga python-is-python3 python3-venv
sudo cp /usr/bin/backup /path/to/directory/
sudo cp /usr/bin/ascript /path/to/directory/
Hii ndio yote unahitaji kwenda na Django katika suala la usakinishaji wa programu kwenye mfano wa Ubuntu. Kwa Windows na Linux hii inapaswa kuwa sawa moja kwa moja, lakini kwa Mac unaweza kutaka kusanikisha mashine ya kawaida na Linux juu yake kwa kutumia mazingira ya bure au ya kulipwa kama VirtualBox au Paralells desktop na kuunda tena hatua zilizo hapo juu ili kuanzisha mazingira ya Ubuntu. Ubuntu ni muhimu katika kesi hii kwa sababu ni programu ambayo tovuti zinaendesha na inawawezesha kuwa mwenyeji wa tovuti na programu yote iliyotajwa hapo juu.

Wacha tuchimba ndani ya Django.

Katika saraka yetu tena, na CD:
backup
python -m venv venv # huunda mazingira halisi ambapo nambari imehifadhiwa Chanzo Venv/bin/Activate # Amsha Enviroment halisi Pip Weka Django Django-Admin StartProject Mysite. # Ambapo MySite ni mradi ninaanza katika saraka yangu ya sasa.

Huunda mazingira halisi ambapo nambari huhifadhiwa

Inaamsha mazingira ya kawaida

Ambapo MySite ni mradi ninaanza katika saraka yangu ya sasa.

Django anatuanzisha tu, kwa sababu Django anashikilia seva ya wavuti na anafanya kila kitu tunachohitaji kupata wavuti ya msingi na inayoendelea. Sasa kwa kuwa tumeweka Django, wacha tuhariri mipangilio kidogo ili kuifanya iweze kufanya kazi jinsi tunahitaji. Kwanza, wacha tuunda programu mpya

Python Management.py StartApp kulisha

Utagundua programu ya kwanza inaitwa kulisha. Programu inapaswa kuitwa chochote unachopenda, na tutaunda programu mpya, lakini jina la kila programu lazima liwe thabiti kila wakati programu inarejelewa kwenye msimbo. Kuongeza programu mpya, tutabadilisha kila wakati mipangilio.py katika saraka nyingine programu iliyoundwa, iliyopewa jina la StartProject, Akhera programu. Kutumia nano,

Nano App/Mipangilio.py

Katika mipangilio, pata kusanikishwa_apps na utenganishe [] katika mistari 3. Kutumia nafasi nne kwenye mstari wa kituo tupu, ongeza 'kulisha', au jina la programu yako. Sehemu hii ya mipangilio.py inapaswa kuonekana kama:
# Imewekwa_apps = [
    'Kulisha',
]
Kabla hatujasahau, wacha tujaribu kwamba Django anafanya kazi. Kutumia amri ya Python Management.py RunServer 0.0.0.0:8000, tunaweza kuendesha seva na kisha kusonga kwenye kivinjari cha wavuti kwenye kompyuta inayoendesha nambari hiyo kwa http: // localhost: 8000 na uone ukurasa wa wavuti (inafanya kazi!) Acha seva na udhibiti C, sawa na amri nyingine yoyote.

Sasa, wacha tuandike kuandika msimbo fulani wa python. Django ina vifaa vitatu kuu, vyote vinaendeshwa kwa nambari kabisa. Vipengele vinaitwa mfano, mtazamo na template, na kila moja iko katika kiwango cha juu na cha chini mtawaliwa kabla ya ukurasa wa wavuti kutolewa kwa mtumiaji.

Mfano ni nambari ambayo huhifadhi habari katika hifadhidata ya kurudisha, mpangilio na utoaji.

Mtazamo unaamua jinsi mfano huo hutolewa, kudanganywa, na kurekebishwa, karibu kila mtazamo utatumia mfano moja kwa moja.

Kiolezo ni nambari ya HTML na kengele za ziada na filimbi zinazoitwa lugha ya template. Kiolezo hutolewa na maoni ambapo imejazwa na msimbo wa python na muktadha kama vile mifano na habari (kamba za utuall na nambari) kutoka kwa maoni.
cd /path/to/directory
git init
git branch -m master
ssh-keygen
Django ina vifaa vingine pia, pamoja na lakini sio mdogo kwa:

Mipangilio, ambayo husanidi programu kama tulivyojadili.

URL, ambazo ni mifumo ambayo mtumiaji hufuata kupata ufikiaji wa sehemu maalum za programu ya wavuti.
cd ~
cat .ssh/id_rsa.pub
Fomu, ambazo hufafanua jinsi habari inayotumwa kwa seva inashughulikiwa na kutolewa kwa hifadhidata na kwa mtumiaji. Hizi ndizo msingi wa usindikaji wa habari kwenye upande wa seva, na zinaweza kukubali aina yoyote ya habari ambayo duka za kompyuta, kamba za maandishi, nambari, na booleans za kweli/za uwongo (kawaida sanduku za ukaguzi).

Kigeuzi, ambacho ni nambari ya HTML na lugha ya template na kuziba pengo kati ya Python na HTML, ikimaanisha kuwa habari ya Python inaweza kutumiwa kama nambari ya HTML ambayo mtu yeyote anaweza kupata na anaweza kupata wavuti na ufikiaji uliozuiliwa, wakati wa kufanya nambari ya Python ipatikane na wavuti na muhimu kwa madhumuni anuwai kwenye kifaa cha mbali ambacho hakiitaji kuwa karibu na seva.

Faili za tuli, ambazo kawaida ni JavaScript na ni maktaba ambazo seva hutumikia na imeunganishwa na template.
git remote add git://… (your remote URL)
Faili za media, ambazo seva hutumikia au inakaribishwa nje, au imeandikwa tu kwa seva kabla ya kusindika na kuchapishwa kwa seva nyingine (ndoo) kwa mwenyeji.

Middleware, ambayo ni vipande vya msimbo ambavyo vinaendeshwa kwa wakati mmoja na kila mtazamo na huzingatiwa "pamoja" kwa maoni.

Wasindikaji wa muktadha, ambao husindika muktadha wa kila mtazamo na hutumiwa kuongeza muktadha wa ziada.

Vipimo, ambavyo vinathibitisha kuwa mtumiaji au ombi hupitisha mahitaji fulani kabla ya maoni kutolewa.

Watumiaji, ambayo inaamuru jinsi wavuti hushughulikia na kujibu mawasiliano.

Admin, ambayo hutumiwa kusajili mifano ili iweze kudanganywa kwa undani ndani ya ukurasa wa admin wa Django, ambapo hifadhidata inaweza kusimamiwa kupitia interface ya picha.

Celery, ambayo inafafanua sehemu za kazi za asynchronous sehemu za nambari ya Django zinaweza kuanza kukimbia kabla ya kuendelea mara moja kwa kazi inayofuata au mstari wa msimbo.

Django inaweza kuwa na vifaa vingine vingi, ambavyo tutajadili kwa undani hapa. Kuna njia nyingi za kufanya Django ifanye kazi zaidi, na kuongeza wavuti, ambazo ni njia za mawasiliano za haraka, zilizoratibiwa, celery, ambayo hufanya kazi za asynchronous, na idadi kubwa ya vipande vingine vya programu ya kupanua Django, haswa katika kazi za mtazamo, ambapo nambari nyingi hutekelezwa. Kazi za kutazama ni muhimu kwa sababu kawaida hutangaza kila kipande cha nambari ambayo ni maalum kwa muundo maalum wa URL, au sehemu ya seva.

Kwanza, wacha tuchunguze kazi za kuona. Kazi za kutazama zinaanza na uagizaji wa nambari ya kuashiria ambayo itatumika kwa mtazamo, na hufafanuliwa kwa kutumia ufafanuzi wa kazi wa kawaida au madarasa. Maoni rahisi hufafanuliwa na ufafanuzi wa kazi, na kurudisha HTTPResponse na template ya msingi. Wacha tuanze kwa kufafanua mtazamo wa msingi kurudisha maandishi "Hello World". Kumbuka kwamba kila wakati unapoongeza nambari baada ya taarifa kama DEF, ikiwa, wakati, kwa, nk, utahitaji kuongeza nafasi 4 kwa kila moja ya ufafanuzi uliotangulia ungependa kutumika kwa kazi yako. Tutaingia katika kila moja ya njia hizi hivi karibuni.

Kutoka kwa saraka ya wavuti yetu, hariri faili ya kulisha/maoni.py kwa kutumia Nano na ongeza mistari ifuatayo hadi mwisho wa faili.

kutoka django.http kuagiza httpresponse Def Hello (ombi): Rudisha Httpresponse ('Hello World')

Httpresponse ya Django inajibu na kamba ya maandishi, iliyoonyeshwa na ufunguzi na kufunga '. Kila wakati unapopitisha habari kwa kazi au darasa, kama ombi au kamba, utahitaji kutumia mabano (, kufungua na kufunga).

Hii sio tu tunahitaji kuona maoni yetu bado. Kwa kweli, hatujaambia seva ambapo maoni ni sawa, bado tunahitaji kufafanua njia ambayo maoni yanapaswa kutoa. Wacha tuanze kwa kufafanua njia ya msingi katika programu/urls.py, na tutaingia kwenye vikundi vya njia baadaye.
python -m venv venv # Katika programu/urls.py, ongeza mstari baada ya taarifa za kuagiza baada ya mwanzo kuingiza maoni ambayo tumeunda tu.
source venv/bin/activate # kutoka kwa maoni ya uingizaji wa kulisha kama malisho ya kulisha
django-admin startproject mysite . # Sasa, wacha tufafanue muundo wa mtazamo. View patterns have three components, the path component, which tells the server where the view exists within the server (the URL path that the user types into the navigation bar to enter the webpage), the view component where the view is specified, and a friendly name for the view so it's easy to retrieve it's pattern when working with a template, especially so it's name can be changed and updated if necessary to make space for another view or take on a more logical name. Inafahamika kufanya mambo kwa njia hii na kubadilika, kwa sababu codebase yako itakuwa mazingira yanayobadilika ambayo yanahitaji kubadilika na uboreshaji ili kuwa na thamani na rahisi kufanya kazi nayo. Hapa kuna maoni yako yataonekana, unaweza kuongeza hii kwenye urlpatterns = [sehemu ya programu/urls.py. Mfano wa mtazamo hufafanuliwa na vitu vitatu vilivyoelezewa hapo juu, na kazi inayoitwa njia. Mifumo yako ya URL ni orodha, kwa hivyo hakikisha kumaliza kila kitu ndani yao na comma, kwa sababu hii hutenganisha kila moja. Kila kitu kinapaswa pia kwenda kwenye mstari mpya, kwa mara nyingine tena na nafasi nne kabla yake, kama programu kwenye Mipangilio.py. Tutafafanua sehemu ya kwanza ya mtazamo na kazi ya kamba tupu, ili kuunda mtazamo unaoendesha kwenye saraka ya mizizi ya seva ya wavuti. Urls yako.py sasa inapaswa kuonekana kama hii:
kutoka kwa maoni ya uingizaji wa kulisha kama malisho ya kulisha urlpatterns = [ njia ('', feed_views.hello, jina = 'hello'), ]

Huu ndio msingi wa kuunda wavuti na Django ambayo ni tuli kabisa. Ili kutengeneza wavuti yenye nguvu zaidi ambapo tunaweza kuanza habari za kuweka habari, kama picha, video, sauti na zaidi, tutahitaji kutumia mifano, ambayo tutachunguza ijayo. Kwa sasa, wacha tuangalie nambari yetu na tuendesha seva. Ili kuangalia nambari ya makosa, endesha:

Python Usimamizi.py Angalia
python manage.py startapp feed
Ikiwa kuna ujumbe wowote wa makosa, unapaswa kukagua kwa uangalifu mabadiliko uliyofanya kwa programu yako na uone ikiwa kuna kitu chochote kinachohitaji kusasishwa, kama nafasi ya nje au ya kukosa, mhusika wa ziada, kamba isiyofunguliwa, typo yoyote, tabia yoyote iliyofutwa kwa bahati mbaya, au kitu kingine chochote. Kusoma kupitia ujumbe wa makosa (ikiwa unayo), unapaswa kuona njia ya faili uliyounda au kuhariri pamoja na nambari ya mstari, kwa hivyo angalia faili hiyo na mstari na uone ikiwa unaweza kurekebisha kitu chochote kilichopo. Ikiwa umerekebisha suala hilo, endesha amri hapo juu tena. Wakati programu yako iko tayari kuendesha na inafanya kazi, utaona "mfumo wa kuangalia haukubainika." Sasa uko tayari kwenda. Run seva na:

Python Management.py RunServer 0.0.0.0:8000

Sasa fungua kivinjari cha wavuti na nenda kwa http: // localhost: 8000. Unapaswa kuona maandishi yamerejeshwa kwenye mabano na nukuu za kazi ya HTTPResponse katika maoni yako. Huu ni mfano tu wa msingi, lakini ikiwa umeifanya hivi sasa, unaelewa misingi ya jinsi Linux, Bash, Python, na Django inavyofanya kazi. Wacha tuingie zaidi kwenye modeli fulani za hifadhidata, na tuchunguze nguvu ya darasa la Python katika kuhifadhi habari. Halafu, tutaanza kupata mtego kwenye HTML na CSS kabla ya kufanya tovuti yetu iwe wazi, kubadilika na salama kwa kutumia JavaScript na kujifunza kwa mashine.
nano app/settings.py
Madarasa yamehifadhiwa kwenye mifano.py ya programu yako. Kutumia nano, hariri programu/models.py na ongeza darasa mpya. Darasa linafafanuliwa na ufafanuzi wa darasa na hupitishwa superclass ambayo inarithi kutoka, katika mifano hii ya mfano.Model. Jina la darasa linakuja baada ya ufafanuzi wa darasa, na baada ya ufafanuzi wa darasa A: (koloni) hutumiwa, kabla ya sifa na ufafanuzi wa kazi uliofungwa kwa darasa umeonyeshwa hapa chini. Darasa letu linahitaji kitambulisho ambacho tunaweza kutumia kuipata na kuiweka ya kipekee, na pia inahitaji uwanja wa maandishi kuhifadhi habari fulani. Baadaye tunaweza kuongeza timestamp, faili, booleans (ufafanuzi wa kweli au wa uwongo ambao unaweza kusaidia nambari yetu kufanya maamuzi juu ya nini cha kufanya na mfano, na inaweza kutumika kuibadilisha), mfano wa kufunga mfano kwa mtumiaji aliyeingia kwenye seva, na zaidi. Wacha tufungue nambari hapa chini:

Kutoka kwa mifano ya kuagiza ya django.db # uingizaji ambao hutumiwa kufafanua darasa letu na ni sifa Chapisho la darasa (modeli.model): # ufafanuzi wa darasa letu yenyewe id = models.autoField (msingi_key = kweli) # Kitambulisho cha mfano wetu, kitufe kinachozalishwa kiatomati ambacho kitaturuhusu kuuliza mfano, kuiweka ya kipekee, na ni muhimu wakati tunahitaji kuingiliana na mfano mara tu imeundwa. maandishi = models.TextField (default = '') # sifa ya duka zetu za darasa, katika kesi hii, maandishi mengine, yakibadilika kwa kamba tupu.

Uingizaji ambao hutumiwa kufafanua darasa letu na ni sifa
INSTALLED_APPS = [
    'feed',
]
Ufafanuzi wa darasa letu yenyewe

Kitambulisho cha mfano wetu, kitufe kinachozalishwa kiatomati ambacho kitaturuhusu kuuliza mfano, kuiweka ya kipekee, na ni muhimu wakati tunahitaji kuingiliana na mfano mara tu imeundwa.

Sifa ya duka zetu za darasa, katika kesi hii, maandishi kadhaa, yakibadilika kwa kamba tupu.

Funga na uhifadhi faili kama tulivyofanya kabla ya kumaliza.

Kuna nyanja zingine nyingi na chaguzi ambazo tutachunguza tunaposasisha darasa hili kama programu yetu inapoibuka, lakini hii ndio mahitaji ya msingi ya kuunda programu ya kutuma maandishi kadhaa. Walakini, mtindo huu hautafanya kazi peke yako. Kama ilivyoelezewa hapo awali, tutahitaji mtazamo wa kawaida na muundo wa URL maalum ili kufanya mfano huu kufanya kazi, na pia tutahitaji fomu pamoja na template. Wacha tuchunguze fomu kwanza.

Ili kufafanua fomu, hariri programu/fomu.py na nano na ongeza mistari ifuatayo. Tutahitaji uagizaji mbili, darasa letu la fomu, na vile vile mfano ambao tumeunda (feed.models.post), ufafanuzi wa darasa sawa na mfano, na uwanja pamoja na subclass inayoitwa meta ambayo itafafanua mfano wa fomu inayoingiliana na. Fomu hiyo pia inaweza kuwa na kazi ya uanzishaji ambayo inaweka juu kulingana na habari katika ombi, mfano au vinginevyo, tutachunguza hii baadaye.

Fomu za mfano ni muhimu sana kwa sababu zinaweza kuunda mfano au pia kuhariri mfano, kwa hivyo tutazitumia kwa wote wawili. Wacha tufafanue moja katika fomu.py hapa chini.

kutoka kwa fomu za kuagiza Django kutoka kwa feed.Models kuagiza chapisho Postform ya darasa (fomu.modelform): maandishi = fomu.charfield (widget = fomu.textarea) Darasa la Meta: mfano = chapisho shamba = ('maandishi',)

Hii ndio misingi ya jinsi fomu na mfano unavyoonekana. Njia hii ya mfano inaweza kutumika kusisitiza au kuhariri chapisho, kubadilisha maandishi yaliyo. Tutaangalia kuunganisha fomu hii kuwa maoni ijayo. Kwanza, wacha tufanye uhamishaji na uhamishe hifadhidata ili nambari yetu iweze kuingiliana na mfano wakati inaendesha. Ili kufanya hivyo, endesha amri zifuatazo:

Python Management.py Makemigrations Python kusimamia.py kuhamia

Hii itachukua dakika kutekeleza, lakini mara itakapofanya hivyo, itakuruhusu kupata mfano katika maoni, middleware, au mahali pengine popote kwenye programu. Wacha tuendelee kwa kufanya maoni ambapo tunaweza kuona mfano wetu. Hariri malisho/maoni.py na ongeza nambari ifuatayo, kama ilivyoonyeshwa. Hautahitaji kuongeza chochote baada ya ishara #, nambari hiyo ni maoni ambayo hutumiwa kuashiria habari kuhusu nambari. Tutaanza kwa kuingiza mfano wetu katika maoni, na kuiongeza kwa muktadha ambapo tunaweza kuipatia katika template kama orodha ya kuonyesha. Ifuatayo, tutaongeza templeti ambapo tunaweza kutoa fomu na mfano na kitufe cha kuunda kitu kipya kulingana na mfano na kuichapisha kwa seva. Hii inasikika kuwa ngumu, kwa hivyo wacha tuichukue hatua kwa hatua. Kabla ya kumaliza maoni, wacha tuunda templeti ambayo inapeana mfano na hakikisha tunaweza kuiona kwa kuunda chapisho jipya kwenye ganda. Hivi ndivyo maoni hayo yanapaswa kuonekana:

kutoka kwa feed.Models kuagiza chapisho Kutoka kwa Django.Shortcuts kuagiza, kuelekeza kutoka django.urls kuagiza reverse Def kulisha (ombi): Machapisho = post.objects.all () # kuuliza machapisho yote kwenye hifadhidata hadi sasa kurudi kutoa (ombi, 'kulisha/kulisha.html', { 'Machapisho': Machapisho, })

Hoja machapisho yote kwenye hifadhidata hadi sasa

Hii yote inaonekana rahisi hadi tufike chini. Toa, thamani iliyorejeshwa na kazi badala ya majibu ya HTTP kama mfano uliopita, daima huchukua ombi kama pembejeo yake ya kwanza, inakubali muktadha (katika kesi hii machapisho kwenye hifadhidata), ambayo sasa inaweza kutolewa kwenye template, na inarudisha templeti iliyoelezewa katika kazi. Kiolezo kitakuwa hati ya HTML na lugha kidogo inayoitwa Jinja2, ambayo inapeana habari ya Python ndani ya HTML.

Kuanza kuunda templeti, tengeneza saraka mbili katika malisho.

Mkdir kulisha/templeti Mkdir kulisha/templeti/kulisha

Ifuatayo, hariri templeti kwenye saraka hapo juu, kulisha/templeti/kulisha, na ongeza nambari ya mfano huu. Wacha tuangalie templeti ya mfano huu.

Malisho { % kwa chapisho katika machapisho %} {{post.text}} { % Endfor %}

Hii ni template rahisi sana. Inafafanua kufungua na kufunga vitambulisho vya HTML, lebo ya aina ya hati, lebo ya mwili na kichwa cha hadithi, lebo ya mapumziko ambayo inaongeza mstari mdogo kwenye skrini, na kitanzi ambacho kinatoa kila chapisho kwenye orodha ya machapisho kama aya kwenye template. Hii ndio yote inachukua kutoa machapisho, lakini hakuna katika hifadhidata bado. Wacha tuunde na ganda. Tunaweza kuendesha ganda na kusimamia.py

Python kusimamia.py ganda

Sasa, wacha tuingize mfano wetu wa posta

kutoka kwa feed.Models kuagiza chapisho

Ifuatayo, tutaunda chapisho rahisi na kamba na kutoka kwenye ganda. Kamba inaweza kuwa chochote, kwa muda mrefu ni maandishi halali.

Post.objects.create (maandishi = 'hello world') Utgång()

Mwishowe, tutahitaji kuongeza muundo wa URL kwenye malisho yetu. Kwa sababu programu yetu ya kulisha itatumia URL nyingi na tunataka kuweka ukubwa wa faili ndogo, wacha tuunda urls.py katika programu yetu ya kulisha ambayo inaonekana kama hii:

Kutoka kwa Django.urls njia ya kuagiza kutoka. maoni ya kuagiza urlpatterns = [ njia ('', maoni.feed, jina = 'kulisha'), ]

Tutahitaji pia kuhariri urls.py kwenye programu ya msingi, chochote tuliamua kuiita, hii ilikuwa saraka ya kwanza tuliyounda. Hariri programu/app.py na ongeza yafuatayo kwa mifumo ya URL

Kutoka kwa Django.urls kuagiza ni pamoja na # juu urlpatterns = [ #... nambari ya hapo awali hapa njia ('kulisha/', ni pamoja na (('feed.urls'), namespace = 'kulisha'), ]

juu

... Nambari ya hapo awali hapa

Sasa, tunapoendesha seva na Python Management.py RunServer, tutaona ukurasa ambao tumeunda kwa sababu tuna mfano, tazama na template na muundo wa URL, pamoja na vitu kwenye hifadhidata. Ifuatayo, wacha tutekeleze fomu tuliyounda na tuanze kuunda machapisho yetu wenyewe. Lakini kabla ya kuandika nambari nyingi, wacha tufanye nakala rudufu kwa kutumia maandishi ambayo tuliandika mapema, Backup. Run maandishi haya kwenye ganda, subiri muda mfupi, na nambari zote zitahifadhiwa kwenye hazina yetu ya git.

chelezo

Utekelezaji wa fomu ni rahisi. Tutaingiza fomu yetu, kuongeza kiboreshaji cha ombi la posta kwa maoni, na kuokoa chapisho kwenye hifadhidata kabla ya kuelekeza kwa mtazamo huo huo. Tunaweza kutumia kazi ya kuelekeza ambayo tayari tumeingiza, na kazi nyingine inayoitwa Reverse kupata URL kwa muundo wa mtazamo. Tutauliza hii na kamba 'Kulisha: Kulisha' kwa sababu nafasi ya jina la muundo uliojumuishwa ni malisho, na maoni pia huitwa kulisha.

kutoka kwa feed.Forms kuagiza Postform Def kulisha (ombi): Machapisho = post.objects.all () # kuuliza machapisho yote kwenye hifadhidata hadi sasa Ikiwa ombi.method == 'chapisho': # Shughulikia ombi la chapisho fomu = postform (ombi.post) # Unda mfano wa fomu na uhifadhi data kwake ikiwa fomu.is_valid (): # hakikisha fomu form.save () # Hifadhi kitu kipya Rudisha uelekeze (reverse ('kulisha: kulisha')) # kuelekeza URL hiyo hiyo na ombi la kupata kurudi kutoa (ombi, 'kulisha/kulisha.html', { 'Fomu': Postform (), # hakikisha kupitisha fomu hiyo katika muktadha ili tuweze kutoa. 'Machapisho': Machapisho, })

Hoja machapisho yote kwenye hifadhidata hadi sasa

Shughulikia ombi la chapisho

Unda mfano wa fomu na uhifadhi data kwake

Thibitisha fomu

Hifadhi kitu kipya

Kuelekeza kwa URL sawa na ombi la kupata

Hakikisha kupitisha fomu hiyo katika muktadha ili tuweze kutoa.

Tag katika HTML na kutoa fomu katika template ya HTML na kitufe cha kuwasilisha. Tutahitaji pia ishara ya CSRF, ishara ambayo inazuia tovuti za nje kutuma kwa fomu bila kwanza kupakia ukurasa.

Malisho { % csrf_token %} {{fomu}} Chapisho jipya { % kwa chapisho katika machapisho %} {{post.text}} { % Endfor %}
from django.http import HttpResponse

def hello(request):
    return HttpResponse('hello world')
Wacha tuvunje hii. Kuna darasa mpya la fomu, ishara, fomu yenyewe, na kitufe cha kuwasilisha. Rahisi sana, lakini tunapoiangalia, tunaweza kutaka kuifanya ionekane bora. Inafanya kazi, tunaweza kutuma machapisho mapya na fomu na sasa yamehifadhiwa kwenye hifadhidata. Kuna mambo machache yanayoendelea hapa. Tunatumia vitambulisho vya HTML kutangaza kwamba hati hiyo ni hati ya HTML, tunatumia tepe ya template ({ %… %}) kutoa ishara kwa fomu, na nyingine, {{…}} kutoa fomu. Pia tuna kitanzi cha kutoa maandishi kwa kutumia vitambulisho vya block na tepe ya template. Vitambulisho vya kuzuia ni muhimu sana kwa sababu tunaweza kufafanua jinsi sehemu za templeti zinavyotolewa nao, na vitambulisho vya template ndio msingi wa jinsi tunavyoweka vigezo kwenye nambari yetu.

Sasa tunahitaji kufanya programu yetu ionekane bora, kwa sababu kwa sasa inaonekana ya msingi kabisa. Tunaweza kufanya hivyo kwa kutumia CSS, ama inline, au katika madarasa yaliyofungwa kwa kila kitu kwenye hati. CSS ni nzuri sana kwa sababu inaambia kila kitu kwenye ukurasa jinsi inapaswa kuonekana, na inaweza kuifanya ionekane nzuri sana. Kuna maktaba chache ambazo zinaweza kufanya hivyo, lakini kwenda kwangu kibinafsi ni Bootstrap.

Getbootstrap.com/

Tengeneza saraka mpya inayoitwa templeti na templeti za MKDIR, na kisha hariri templates/base.html.

Inapaswa kuonekana kama hii:

{ % block mwili %} { % endblock %}

Hakikisha kunakili CSS na JavaScript, faili za .css na .js, kwa sababu tutahitaji JavaScript ili kufanya tovuti yetu ifanye kazi zaidi katika siku zijazo.
from feed import views as feed_views
Sasa, wacha turudi kwenye ganda la bash na tuendesha amri ya haraka. Kumbuka, ikiwa unahitaji kupata mazingira ya kawaida, aina ya chanzo Venv/bin/actishate. Hii itakuruhusu usakinishe vifurushi vya Python ndani kwa njia ambayo inaruhusu Django kuzifikia. Ili kutoa fomu zetu zinazozalishwa na madarasa ya Django Bootstrap, tutatumia kifurushi cha Python kinachoitwa Fomu za Crispy. Tunaweza kupakua hii na amri ifuatayo

PIP Ingiza fomu za Django-crispy

Mara hii imewekwa, ongeza kwenye mipangilio.py
from feed import views as feed_views

urlpatterns = [
    path('', feed_views.hello, name='hello'),
]
Imewekwa_apps = [ #… Nambari ya hapo awali hapa 'crispy_forms', ]

… Nambari ya zamani hapa

Sasa, nyuma kwenye templeti yetu ya kulisha, tunaweza kuondoa vitu kadhaa. Wacha tuondoe mwanzo na mwisho wa hati na uibadilishe na urithi kutoka kwa template yetu ya msingi, kwa kutumia upana na ufafanuzi wa block. Pia, tutaongeza uingizaji wa kichujio cha template na mzigo na kichujio cha template kwenye fomu. Mwishowe, wacha tuongeze darasa la bootstrap kwenye kitufe kwenye fomu ili kuifanya ionekane kama kitufe. Hiyo inapaswa kuonekana kama hii:
python manage.py check
{ % hupanua 'msingi.html' %} { % block mwili %} { % mzigo crispy_forms_tags %} { % csrf_token %} {{fomu | crispy}} Chapisho jipya { % kwa chapisho katika machapisho %} {{post.text}} { % Endfor %} { % endblock %}

Mzuri! Hiyo ni nambari kidogo tayari. Ifuatayo, tunapaswa kuijaribu na kuhakikisha tunaweza kuona kuwa kila kitu kinaonekana kizuri, na pia hakikisha kila kitu kinafanya kazi vizuri. Run seva kama ilivyo kwa maagizo ya zamani na hakikisha tovuti inaonekana na inafanya kazi sawa. Kazi kubwa! Uko tayari kuendelea kwenye hatua inayofuata, ambayo tutaongeza utendaji wa kuingia kwa watumiaji kwa kutumia URL zinazofanana, fomu, maoni na templeti. Kiolezo cha msingi ni muhimu, na tutaendelea kuibadilisha na kufanya mabadiliko kama inahitajika, lakini kwa sasa wacha tuangalie kufanya tovuti yetu iwe salama zaidi, kwa kuwezesha watumiaji kuingia na jina la mtumiaji na njia ya kupita, na mwishowe habari muhimu zaidi ambayo itasaidia kuweka programu yako salama na akaunti yako mwenyewe ipatikane na wewe tu.

Ili kufanya hivyo, tutahitaji kutumia mfano wa mtumiaji uliojengwa ndani ya Django. Mfano wa mtumiaji ni mfano wa hifadhidata, kama chapisho letu, ambalo linaweza kutolewa ili kuingia kwa mtumiaji kwenye wavuti. Katika siku zijazo, kabla ya kupeleka tovuti kwenye mtandao, tutapanua mfano huu na mifano mingine inayohusishwa nayo, na tujenge hatua za usalama za ziada za kuingia ambazo ni sugu kwa ulaghai. Tutaanza kwa kutumia zingine zilizojengwa katika fomu za kuingia ambazo Django hutoa. Kwanza, wacha tuunda programu mpya ambayo tutatumia kutoa templeti na maoni ya ukurasa wa msingi wa kuingia. Pia tutaunda programu zingine kuwakilisha changamoto zinazoendelea za kuingia ili kupata programu, pamoja na pincode, utambuzi wa usoni, mawasiliano ya uwanja karibu, vifaa vya nje, uthibitisho wa sababu nyingi, na utambuzi wa alama za vidole.
python manage.py runserver 0.0.0.0:8000
Tayari tumezungumza juu ya kuanzisha programu. Kutoka kwa saraka yetu, ndani ya mazingira ya kawaida, kupitisha usimamizi.py hoja hizi

Watumiaji wa Python Management.py

Sasa, tunapaswa kuwa na saraka ya programu mpya. Wacha tuanze kwa kuunda maoni katika saraka hiyo ambayo inalingana na kuingia kwa mtumiaji. Django imeunda katika maoni ya kuingia kwa watumiaji, lakini haya hayatafaa kwetu kwa sababu tunahitaji mtazamo wa kawaida, ambao unawezekana kufanywa na ufafanuzi.

Katika maoni haya, tutaanza kwa kuangalia ombi la posta, kupitisha ombi.Post kwa kuingia kwa nje kutoka kwa Django, kuthibitisha akaunti ya mtumiaji, na kuingia kwa mtumiaji kabla ya kuielekeza kwenye programu yetu ya malisho.

Katika watumiaji/maoni.py, ongeza nambari ifuatayo
from django.db import models # Kutoka kwa Django.Shortcuts kuagiza, kuelekeza
kutoka django.urls kuagiza reverse
kutoka django.contrib.auth.Forms Uthibitishaji wa Uthibitishaji, setPasswordform
kutoka django.contrib.auth kuagiza dhibitisha, logi
kutoka django.contrib.auth kuagiza kuingia kama Author_Login
Kutoka kwa Django.contrib Ujumbe wa kuagiza

def kuingia (ombi):
    Ikiwa ombi.method == "chapisho":
        jina la mtumiaji = ombi.post ['jina la mtumiaji'] # Pata jina la mtumiaji na nywila kutoka kwa ombi la chapisho
        nywila = ombi.post ['nywila'] # thibitisha mtumiaji
        Mtumiaji = thibitisha (jina la mtumiaji = jina la mtumiaji, nywila = nywila)
        Ikiwa mtumiaji:
            AUTH_Login (ombi, mtumiaji, backend = 'django.contrib.auth.backends.modelbackend')
            Ujumbe.Success (ombi, 'Nenosiri lako lilikubaliwa. Tafadhali Endelea')
            Rudisha uelekeze (reverse ('kulisha: kulisha'))
        mwingine: ujumbe.warning (ombi, 'jina la mtumiaji au nywila sio sahihi. Tafadhali jaribu tena')
    Rudisha kutoa (ombi, 'watumiaji/login.html', {'fomu': uthibitishajiForm ()})
class Post(models.Model): # Pata jina la mtumiaji na nywila kutoka kwa ombi la chapisho
    id = models.AutoField(primary_key=True) # Thibitisha mtumiaji
    text = models.TextField(default='') # Hii ndio unahitaji kwa mtazamo wa kimsingi wa kuingia. Sasa, wacha tuunda fomu ya maoni kwa kupanua template ya msingi. Tutaanza kwa kuunda saraka mpya ya templeti kwenye folda ya Watumiaji.
Watumiaji wa MKDIR/templeti Watumiaji wa MKDIR/templeti/watumiaji

Sasa, tunapaswa kuhariri watumiaji/templeti/watumiaji/login.html. Wakati tuko ndani yake, tutaunda templeti ili kumruhusu mtumiaji kujisajili pia.

Watumiaji wa Nano/templeti/watumiaji/login.html

Sasa, kwenye templeti,

{ % hupanua 'msingi.html' %} { % mzigo crispy_forms_tags %} { % block yaliyomo %} { % csrf_token %} Ingia {{fomu | crispy}} Ingia { % endblock %}

Hii ndio misingi ya template ya kuingia. Ni kweli kama template nyingine katika muundo, lakini inaonekana tofauti kidogo wakati inatolewa. Tunaweza kunakili nambari hii ili kujenga template nyingine inayofanana inayoitwa rejista.html, ambapo tutabadilisha maneno na kutumia fomu mpya tunayoijenga. Wacha tufanye template kwanza. Hariri watumiaji/templeti/watumiaji/rejista.html na ongeza nambari ifuatayo:

{ % hupanua 'msingi.html' %} { % mzigo crispy_forms_tags %} { % block yaliyomo %} { % csrf_token %} Unda akaunti {{fomu | crispy}} Jisajili { % endblock %}

Sasa, wacha tujenge fomu ya usajili wetu wa watumiaji na uzunguke nyuma kwa maoni kabla ya kusasisha logi zetu za watumiaji na mfano. Tutafanya fomu hii ya msingi kuanza, lakini kuingiza maelezo zaidi na huduma za usalama kama vile makubaliano na CAPTCHA katika siku zijazo. Hariri fomu na watumiaji wa nano/fomu.py, na ongeza nambari ifuatayo.

kutoka kwa fomu za kuagiza Django kutoka django.contrib.auth.Models Mtumiaji wa kuagiza kutoka django.contrib.auth.Forms kuagiza utumiaji Darasa la mtumiajiRegisterForm (UserCrationForm): Barua pepe = Fomu.EmailField () Darasa la Meta: mfano = mtumiaji shamba = ['jina la mtumiaji', 'barua pepe', 'password1', 'password2']
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',)
Kwa hivyo tuna fomu nyingine hapa, ambayo inafanya kazi kwa haki. Ni fomu ya usajili wa watumiaji na jina la mtumiaji, barua pepe na nywila, na pia uwanja wa nywila. Kumbuka kuwa fomu hii haiongezei darasa la kawaida.Form, ni fomu ya mfano ambayo inamaanisha ina meta. Sehemu moja hufafanuliwa sawa, na meta ya darasa inafafanua mfano fomu inalingana na habari iliyobaki ambayo itaandikwa kwa fomu. Zaidi ya hii tayari ipo katika Django iliyojengwa katika utumiaji, kwa hivyo tutatumia hiyo kama msingi wa darasa (iliyopitishwa kwenye mabano).

Ifuatayo, tutachunguza maoni ya kusajili mtumiaji, sasa kwa kuwa tunayo fomu na template. Hii ni modelf, kama ile iliyo kwenye mtazamo mpya wa chapisho. Hariri watumiaji/maoni.py na ongeza nambari ifuatayo:

#… Uagizaji kutoka .Forms kuagiza mtumiajiRegisterForm Usajili wa DEF (ombi): Ikiwa ombi.method == "chapisho": fomu = mtumiajiRegisterForm (ombi.post) ikiwa fomu.is_valid (): mtumiaji = fomu.save () Ujumbe.Success (Ombi, 'Karibu kwenye programu, {}.'. (Mtumiaji.username)) Rudisha kutoa (ombi, 'watumiaji/rejista.html', {'fomu': mtumiajiRegisterForm})
python manage.py makemigrations
python manage.py migrate
… Uagizaji

Hii ndio yote tunayohitaji kupata mtumiaji aliyesajiliwa, lakini tunapaswa kuwa na habari zaidi. Tunataka kujua wakati mtumiaji amesajiliwa, ni wakati gani walikuwa wa mwisho kwenye wavuti, habari fulani juu yao, kama wasifu, wakati wa eneo, nk Pia, tutahitaji kusasisha mfano wetu wa kulisha, chapisho, akaunti ya mfano wa mtumiaji na machapisho ya sifa kwa kila mtumiaji. Ili kufanya hivyo, tutasasisha mifano.py katika programu zote mbili. Wacha tuanze kwa kuhariri mfano wa kulisha. Inapaswa kuonekana kama hii sasa:

Kutoka kwa mifano ya kuagiza ya Django.db #… uagizaji kutoka django.contrib.auth.Models Mtumiaji wa kuagiza chapisho la darasa (modeli.model): id = models.autoField (msingi_key = kweli) mwandishi = models.ForeignKey (mtumiaji, on_delete = models.cascade, null = kweli, tupu = kweli, uhusiano_name = 'machapisho') # ongeza kwenye mstari huu maandishi = models.TextField (chaguo -msingi = '')
    posts = Post.objects.all() # … Uagizaji
Ongeza kwenye mstari huu

Makini na mstari wa pili ambao uliongezwa kwenye faili. Hii ni ufunguo wa kigeni, ambao utaonyesha kila chapisho kwa mtumiaji mmoja kwa kila chapisho, kwa hivyo tunaweza kuhakikisha kuwa tunaokoa machapisho kwa msingi wa watumiaji na hakuna chapisho linaloweza kufanywa bila kuionyesha kwa mtumiaji. Tunafafanua kitufe hiki cha kigeni na darasa linalowakilisha, hoja ya kufuta ili kuhakikisha kuwa machapisho yanafutwa na watumiaji, hoja zisizo wazi na tupu ili kuhakikisha kuwa tunaweza kuondoa mtumiaji ikiwa ni lazima, na kubeba kwa ukosefu wa mtumiaji kwenye machapisho ambayo tumeunda tayari, na jina linalohusiana, ambalo tunaweza kutumia kurejelea vitu vya posta ambavyo mtumiaji huunda. Jina hili linalohusiana, tofauti na Post.Author, mwandishi wa chapisho hilo, hutupa mtumiaji aliyetuma chapisho lenyewe. Tunaweza sasa kupata machapisho ambayo mtumiaji aliyotengenezwa na kuendesha mtumiaji.posts.all (), au mwandishi.posts.all ().

Sasa, wacha tufanye kuingia kwetu kustahimili zaidi. Tayari tunaweza kufanya tovuti yetu iwe chini ya hatari ya ulaghai kwa kiwango cha kupunguza idadi ya nyakati ambazo tutaruhusu kuingia kwenye tovuti, hii ni rahisi sana. Wacha pia tuanze kuhifadhi habari fulani juu ya kila mtumiaji kabla tunapoendelea kukuza programu yetu. Kuhariri watumiaji/modeli.py, ongeza nambari ifuatayo.

Kutoka kwa mifano ya kuagiza ya Django.db. kutoka django.contrib.auth.Models Mtumiaji wa kuagiza kutoka django.utils kuagiza saa ya saa Profaili ya darasa (modeli.model): Mtumiaji = Models.ToNoOneField (mtumiaji, on_delete = models.cascade, null = kweli, tupu = kweli, uhusiano_name = 'wasifu') Akaunti_created = Models.DateTimeField (chaguo -msingi = Timezone.Now) Last_seen = Models.DateTimeField (chaguo -msingi = Timezone.Now) can_login = models.dateTimeField (chaguo -msingi = timezone.now) prepared_name = models.charfield (max_length = 20, default = '', null = kweli, tupu = kweli) bio = models.TextField (tupu = kweli, chaguo -msingi = '')

Kumbuka kuwa mfano huu ni sawa na mfano wa chapisho. Tunayo uingizaji wa ziada, TIMEZONE, ambayo itaturuhusu kuweka defaults kwenye uwanja wa Tarehe, na pia tunayo tabia na uwanja wa maandishi kama chapisho. Kutumia njia hizi zote za nyakati hutusaidia kupata tovuti na kuelewa matumizi yake, na sehemu za maandishi zinaturuhusu kutoa habari juu ya kila mtumiaji, au mwandishi, kwenye Wavuti. OneToonefield inapaswa kuwa maanani ndogo tu, ina tabia sawa na mtangulizi lakini na mfano mmoja tu kwa mfano. Kwa njia hii, mtumiaji ana wasifu mmoja tu, wakati wanaweza kuwa na machapisho mengi.
mkdir feed/templates
mkdir feed/templates/feed
Sasa, wacha tuboresha kuingia kwetu na kujiandikisha maoni ya akaunti kwa wasifu. Kwanza, hariri watumiaji/maoni.py na uzingatia maoni ya usajili:

#… Uagizaji kutoka .Forms kuagiza mtumiajiRegisterForm Usajili wa DEF (ombi): Ikiwa ombi.method == "chapisho": fomu = mtumiajiRegisterForm (ombi.post) ikiwa fomu.is_valid (): mtumiaji = fomu.save () Wasifu.objects.create (mtumiaji = mtumiaji) # hakikisha kuongeza mstari huu, kuunda wasifu kwa mtumiaji Ujumbe.Success (Ombi, 'Karibu kwenye programu, {}.'. (Mtumiaji.username)) Rudisha kutoa (ombi, 'watumiaji/rejista.html', {'fomu': mtumiajiRegisterForm})

… Uagizaji
Hakikisha kuongeza laini hii, kuunda wasifu kwa mtumiaji

Hii inaunda wasifu kwa mtumiaji, bila kujaza habari yoyote. Sasa, tunataka kuhakikisha kuwa akaunti ya mtumiaji haiwezi kuingia mara nyingi sana, au angalau nywila haziwezi kujaribiwa mara nyingi, kwa hivyo wacha tusasishe mtazamo wa kuingia.

#… Uagizaji kutoka .Models Profaili ya kuagiza kutoka django.utils kuagiza saa ya saa kuagiza wakati wa tarehe def kuingia (ombi): Ikiwa ombi.method == "chapisho": jina la mtumiaji = ombi.post ['jina la mtumiaji'] nywila = ombi.post ['nywila'] Mtumiaji = thibitisha (jina la mtumiaji = jina la mtumiaji, nywila = nywila) Ikiwa mtumiaji na mtumiaji.profile.can_login <timezone.now (): # kumbuka kuwa sasa tunaangalia ikiwa mtumiaji anaweza kuingia AUTH_Login (ombi, mtumiaji, backend = 'django.contrib.auth.backends.modelbackend') Ujumbe.Success (ombi, 'Nenosiri lako lilikubaliwa. Tafadhali endelea.') Rudisha uelekeze (reverse ('kulisha: kulisha')) mwingine: # ikiwa kuingia hakufanikiwa, ujumbe.warning (ombi, 'jina la mtumiaji au nywila sio sahihi. Tafadhali jaribu tena.') mtumiaji = mtumiaji.objects.filter (jina la mtumiaji = jina la mtumiaji) .first () # hii ndio sehemu ambayo tunasasisha wasifu wa watumiaji Ikiwa mtumiaji: wasifu = mtumiaji.profile wasifu.can_login = timezone.now () + dateTime.timedelta (sekunde = 15) # kwa hivyo hawawezi kuingia tena kwa sekunde chache wasifu.save () Rudisha kutoa (ombi, 'watumiaji/login.html', {'fomu': uthibitishajiForm ()})
python manage.py shell
… Uagizaji

Kumbuka kuwa sasa tunaangalia ikiwa mtumiaji anaweza kuingia

Ikiwa kuingia hakufanikiwa,
from feed.models import Post
Hii ndio sehemu ambayo tunasasisha wasifu wa watumiaji

Kwa hivyo hawawezi kuingia tena kwa sekunde chache

Hii ndio msingi wa usalama. Hakikisha tovuti hiyo sio hatari kwa mtu anayejaribu kila mchanganyiko wa nywila, au hata wachache wao kwa wakati mmoja. Hii haitasikitisha kwa mtumiaji wa kawaida ambaye anajua nambari yao ya kupita na huingia tu kwenye vifaa vichache, lakini itaweka roboti nyingi za ulaghai kutoka kwa programu. Kumbuka kwamba tumeongeza taarifa ya IF na kutofautisha, can_login, ambayo inapaswa kuwa wakati wa zamani, na kuisasisha kwa kila kuingia bila kufanikiwa kwa kutumia jina moja la mtumiaji. Kwa njia hii, mtumiaji mbaya hataweza kudhani nywila mahali popote karibu haraka. Idadi ya sekunde katika DateTime.timedelta () inaweza kusasishwa pia, na wavuti itakuwa yenye nguvu zaidi lakini haiwezekani kidogo na sekunde zaidi. Ninapendekeza 15 kuanza na.
Post.objects.create(text='hello world')
exit()
Kumbuka, tuliunda hati ya chelezo ili kuokoa kazi yetu, kwa hivyo wacha tuende mbele na tuhifadhi kile tulichonacho hadi sasa ili kuhakikisha kuwa kila kitu kimeokolewa. Endesha amri:

Backup ya Sudo

Kwa mara nyingine, hii itaokoa kazi yako hadi sasa. Ninapendekeza kuendesha backups za mara kwa mara ili kuokoa kazi yako, na unaweza hata kutaka kuendesha kazi ya chelezo moja kwa moja. Unaweza kufanya hivyo kwa kutumia matumizi ya UNIX inayoitwa cron. Ili kuamsha matumizi haya, endesha amri ifuatayo na ingiza nywila yako:
from django.urls import path
from . import views

urlpatterns = [
    path('', views.feed, name='feed'),
]
sudo crontab -e

Ikiwa haujachagua chaguo 1 kwa Nano, mhariri wa maandishi unapaswa kuwa tayari kufahamiana na, na tembeza chini ya faili ukitumia funguo za mshale. Ongeza mstari ufuatao:

0 * * * * Backup ya Sudo
from django.urls import include # Cron hutumia dakika ya fomati, saa, siku ya mwezi, mwezi, siku ya wiki, ambapo * au nambari inawakilisha wakati wa kuendesha amri. Kutumia 0 kwa dakika na * kwa chaguzi zingine, tunaweza kuendesha amri kwenye dakika ya kwanza ya kila saa mwanzoni mwa dakika. Hii inaturuhusu kuhifadhi nambari moja kwa moja. Kazi zote za Cron wakati zinatekelezwa na Sudo Run kama mzizi, kwa hivyo hatutahitaji kuchapa nywila kila saa.
    # Ili kuifanya iwe rahisi kuhifadhi nambari yetu bila kutumia nywila, wacha tuzima nywila kwa amri yetu ya chelezo. Tutafanya hivyo kwa kutekeleza amri ifuatayo na kuingiza nywila:
Sudo Visudo

Sasa, wacha tuangalie chini ya faili na kuongeza mstari mwingine:

Yote = nopasswd: /bin /chelezo
backup
Hii inaturuhusu kuendesha amri "Backup" kama mtumiaji yeyote, bila nywila. Fomati ya hii ni rahisi, kiambishi tu mstari na "Zote = NopassWd:/bin/" na mwisho na amri, kwa mfano/bin/Backup, ambayo iko katika/usr/bin/.

Sasa, wacha tuanze kufanya kazi na barua pepe. Barua pepe ni muhimu sana kwa wavuti, kwa sababu ni njia ya kuweka wavuti salama zaidi, kuthibitisha watumiaji ni watu halisi, na hata bidhaa za soko au huduma kwa wateja. Watu wengi ambao mara kwa mara mtandao huangalia barua pepe zao kila siku, na wanapokea kila aina ya barua pepe ya uuzaji kuhusu bidhaa na huduma wanazopendezwa. Kuna chaguzi chache linapokuja kuwezesha barua pepe kwenye wavuti ya Django, na unakaribishwa kuchagua chochote kinachofanya kazi vizuri kwako.

Kwanza, unaweza kulipia huduma ya barua pepe ambayo itakuwezesha kutuma barua pepe kutoka kwa kikoa chako na inahitaji nambari ndogo. Kuna huduma nyingi ambazo hutoa hii, kama vile Google WorkSpace, SendInBlue, Mailgun, na zaidi.
    posts = Post.objects.all() # Vinginevyo, uko vizuri kujenga huduma yako mwenyewe ya barua pepe ndani ya seva yako kutoka mwanzo. Ninapendekeza chaguo hili, ingawa ni nambari zaidi na inaweza kuhitaji mwenyeji maalum. Hautaweza kuanza seva ya barua kutoka kwa kompyuta yako ya nyumbani uwezekano mkubwa, kwa hivyo wacha tuende mbele na tuchunguze usanidi na nambari ya kutuma barua pepe kabla ya kuanza seva kwenye wingu na tuunda seva yetu ya barua ndani.
    if request.method == 'POST': # Kwanza, hariri mipangilio.py na amri ifuatayo:
        form = PostForm(request.POST) # Nano App/Mipangilio.py
        if form.is_valid(): # Ambapo programu ni jina la programu uliyounda na StartApp.
            form.save() # Ongeza mistari ifuatayo:
        return redirect(reverse('feed:feed')) # Tovuti_name = 'programu ya django'

Barua pepe_backend = 'django.core.mail.backends.smtp.emailbackend'
Barua pepe_host = 'localhost'
Barua pepe_port = 587
Barua pepe_use_tls = kweli
Barua pepe_address = sername@server.com '
Barua pepe_host_user = 'jina la mtumiaji'
Barua pepe_host_password = usanidi ['barua pepe_host_password']
Default_from_email = '{} <{}>'. Fomati (tovuti_name, barua pepe_host_user)
        'form': PostForm(), # Hakikisha kubadilisha hizi wakati uko tayari kupeleka programu yako, tutatazama tena hii baadaye. Mpangilio wa barua pepe_address unapaswa kuwa barua pepe ambayo ungependa kutuma kutoka, na nywila (barua pepe_host_password) inapaswa kuweka kwa nywila unayotoa kwa seva. Ninapakia nywila kutoka kwa faili ya usanidi ili kuiweka nje ya nambari kwa kutumia mantiki ifuatayo, juu ya mistari hii kwenye mipangilio.py:
kuagiza OS kuagiza JSON na wazi ('/nk/config.json') kama config_file: Config = json.load (Config_File)

Halafu, nimeanzisha faili ya JSON na usanidi katika /etc/config.json kwa kutumia Nano kama ifuatavyo.

Ili kuhariri faili:

Sudo Nano /etc/config.json
Ongeza mistari ifuatayo:

{ "Barua pepe_host_password": "" }

Tutaendelea kuhariri faili ya usanidi na kuongeza nywila zote na funguo ambazo tutatumia kwenye programu. Kwa sasa, wacha tuchunguze haraka jinsi ya kutuma barua pepe kwa kutumia Python. Kwanza, wacha tuunda template kwa barua pepe ya uthibitishaji tunaweza kutuma kwa watumiaji wetu, na kuiweka kwenye saraka ya templeti za mtumiaji. Kiolezo hiki kitaandikwa katika HTML.

Watumiaji wa Nano/templeti/watumiaji/uthibitisho_email.html

Programu ya Django - Thibitisha barua pepe yako Mpendwa {{mtumiaji.username}}, Ili kuthibitisha barua pepe yako, tafadhali bonyeza hapa. Vinginevyo, unaweza kubandika kiunga kifuatacho kwenye bar ya anwani ya kivinjari chako: {{base_url}} { % url 'watumiaji: amilisha' uidb64 = uid token = ishara %} Kiunga kitaisha kwa dakika 30. Ikiwa haujaomba barua pepe ya uthibitisho unaweza kupuuza barua pepe hii tu. Tutaonana hapo, Daisy

Barua pepe hii ni rahisi. Inachukua muktadha wa mtumiaji, URL ya msingi ya Tovuti, na kitambulisho cha mtumiaji na ishara ambazo hutumiwa kuthibitisha barua pepe ya mtumiaji. Hakikisha kufafanua URL ya msingi katika Mipangilio.py kabla ya kuandika nambari ya Python kutoa template. Nenda mbele na ongeza mistari ifuatayo kwa programu/mipangilio.py, karibu na mwanzo.Tovuti_name = 'programu ya django' Itifaki = 'https' Kikoa = 'mfano.com' Base_url = itifaki + ': //' + kikoaMwishowe, wakati tovuti yako iko tayari kwa mtandao na unaipeleka, utataka kufafanua kikoa chako kama jina la kikoa unachonunua kuwakilisha tovuti. Hili ndilo jina ambalo utaandika katika Navbar ili kufikia tovuti yako. Kwa sasa, unaweza kuacha kikoa tupu au kutumia mahali. Pia utataka kubadilisha jina la tovuti kuwa jina ambalo unataka kutoa tovuti yako, ya chaguo lako.

Kabla ya kutuma barua pepe, wacha tuunda jenereta ya ishara ili tuweze kuwa na ishara ya uanzishaji wa akaunti ambayo haimalizika. Tunaweza kufanya hivyo kwa kujenga na kuingiza ishara ya uanzishaji wa akaunti ambayo inaonekana kama yafuatayo. Hariri faili:

Watumiaji wa Nano/Tokens.py

Ongeza nambari ifuatayo:

kutoka django.contrib.auth.tokens kuagiza passwordresettokengenerator kuagiza sita Darasa la Tokengenerator (passwordresettokengenerator): def _make_hash_value (ubinafsi, mtumiaji, timestamp): kurudi ( sita.text_type (mtumiaji.pk) + sita.text_type (Timestamp) ) Akaunti_activation_token = Tokengenerator () kujiondoa_token = tokengenerator ()

Jenereta hii ya msingi ya ishara hutoa ishara ambayo tunaweza kutuma mtumiaji katika URL na mtumiaji anaweza kutumia kuthibitisha barua pepe yao na kuamsha akaunti yao.
Ifuatayo, wacha tuone jinsi ya kutuma barua pepe. Kutumia nano, hariri watumiaji/barua pepe.py.

watumiaji wa Nano/barua pepe.py

Kutuma barua pepe ya uthibitisho wa HTML itaonekana kama hii:

kutoka django.contrib.auth kuagiza kupata_user_model kutoka django.utils.http kuagiza urlsafe_base64_encode, urlsafe_base64_decode kutoka django.contrib.sites.shortcuts kuagiza kupata_current_site kutoka django.core.Mail kuagiza send_mail kutoka django.template.loader kuagiza Render_to_string kutoka django.utils.encoding kuagiza force_bytes kutoka django.core.Mail kuagiza barua pepeMultialternatives kutoka Django.Shortcuts kuagiza kutoka .tokens kuagiza akaunti_activation_token kutoka django.template.loader kuagiza Render_to_string kutoka django.utils.html kuagiza strip_tags Kutoka kwa Django.Template template ya kuagiza, muktadha Kutoka kwa mipangilio ya kuagiza ya Django.conf kuagiza traceback def send_verification_email (mtumiaji): Mtumiaji = kupata_user_model () mail_subject = '[{}] Anzisha akaunti yako.'. (Mipangilio.site_name) html_message = Render_to_string ('watumiaji/uthibitisho_email.html', { 'Mtumiaji': Mtumiaji, 'Domain': Mipangilio.Domain, 'Itifaki': 'Https', 'uid': urlsafe_base64_encode (force_bytes (mtumiaji.pk)), 'Ishara': Akaunti_activation_token.make_token (mtumiaji), }) send_html_email (mtumiaji, mail_subject, html_message)

Hii ni rahisi. Tunaingiza kazi tunazohitaji kutuma barua pepe, kutoa barua pepe na templeti, na mipangilio yetu, halafu tunafafanua barua pepe kwa jina la template na tupeleke kwa mtumiaji kwa kutumia kazi. Utagundua hatujaelezea kazi ya kutuma barua, send_html_email, bado, kwa hivyo wacha tuandike hii chini ya nambari ambayo tumeongeza tayari kwa watumiaji/barua pepe.py
pip install django-crispy-forms
def send_html_email (mtumiaji, mail_subject, html_message): to_email = mtumiaji.email jina la mtumiaji = mtumiaji.username ikiwa kwa_email == '': kurudi hakuna unsub_link = mipangilio.base_url + mtumiaji.profile.create_unsubscribe_link () html_message = html_message + "kujiondoa" msg = barua pepeMultialTernatives (mail_subject, strip_tags (html_message), mipangilio.default_from_email, [to_email], vichwa = {'orodha-unsubscribe': '<' + unsub_link + '>'},) msg.attach_alternative (html_message, "maandishi/html") wasifu = mtumiaji.profile jaribu: msg.send (kushindwa_silely = uongo) Ikiwa sio wasifu.email_valid: wasifu.email_valid = kweli wasifu.save () isipokuwa: wasifu.email_valid = uongo wasifu.save ()

Hii ni ngumu zaidi, na hatuko tayari kuendesha nambari hii yote bado. Angalia tunafafanua unsub_link, kiunga ambacho mtumiaji anaweza kutumia kujiondoa kutoka kwa barua pepe zetu. Hii ni muhimu, kwa sababu watumiaji watahitaji kuchagua kutoka kwa barua pepe zetu isipokuwa wanataka kuwaona, wakati wowote. Tunaongeza pia maandishi mbadala kwa ujumbe wetu, ambayo ni ujumbe wa HTML uliovutwa kwa vitambulisho vya HTML. Mwishowe, tunaangalia ikiwa barua pepe ilituma, na ikiwa haikufanya hivyo, tunaweka alama kwenye wasifu wa mtumiaji kwamba barua pepe yao sio halali.

Wacha turudi kwenye mifano ya watumiaji ili tuweze kufanya hii yote ifanye kazi. Tunahitaji kufafanua kazi ya kutengeneza kiunga cha kujiondoa, na kufafanua uwanja wa Boolean kuashiria kuwa barua pepe ya mtumiaji sio halali.
    # Kwanza, ongeza uagizaji ufuatao juu ya watumiaji/modeli.py
Watumiaji wa Nano/Models.py

#… kutoka django.core.Signing kuagiza timestampsigner, badsignature, sainiExpired kutoka django.urls kuagiza reverse

Kama
Ifuatayo, wacha tuongeze kazi kwa mfano wa mtumiaji kutengeneza ishara na angalia ishara inayotumika kuamsha barua pepe, na vile vile uwanja wa kuokoa ikiwa mtumiaji anapokea barua yao kwa mafanikio. Katika watumiaji/models.py Tena, ongeza nambari ifuatayo hadi mwisho wa mfano (nambari ya indented)

#… barua pepe_valid = models.booleanfield (chaguo -msingi = kweli) def make_token (ubinafsi): Rudisha timestampsigner (). ishara (self.user.username) def check_token (ubinafsi, ishara): jaribu: ufunguo = '%s:%s'%(self.user.username, ishara) TimeStampSigner (). Unsign (ufunguo, max_age = 60 * 60 * 24 * 30) # halali kwa siku 30 isipokuwa (badsignature, sainiExpired): kurudi uwongo Rudi kweli def kuunda_unsubscrict_link (ubinafsi): jina la mtumiaji, ishara = self.make_token (). mgawanyiko (":", 1) kurudi nyuma ('watumiaji: kujiondoa', Kwargs = {'jina la mtumiaji': jina la mtumiaji, 'ishara': ishara,})

Kama

Halali kwa siku 30

Hii ni rahisi, tunatumia timestampsigner, ambayo ni zana ya msingi ya maandishi, kuunda ishara ambayo itaisha baada ya muda fulani, na pia tunatumia kazi nyingine kuangalia ikiwa ni halali. Tunatumia ishara hizi mara mbili, mara moja kuthibitisha barua pepe, na mara moja kwa kiunga cha kujiondoa.

Sasa kwa kuwa tunayo, ya mwisho ya kazi ambayo tutahitaji kufanya ni katika maoni. Ndani ya watumiaji/maoni.py, wacha tuongeze maoni ili kuthibitisha anwani ya barua pepe, na kujiondoa.

watumiaji wa nano/maoni.py
python manage.py startapp users
Kwanza, ongeza uagizaji ufuatao. Nilitupa nyongeza chache ili hatutalazimika kuagiza vitu zaidi tena baadaye.

kutoka django.contrib.auth kuagiza logout Kutoka kwa Django.Shortcuts kuagiza, kuelekeza, kupata_object_or_404 kutoka django.contrib.auth.Models Mtumiaji wa kuagiza kutoka django.utils.Encoding kuagiza Force_str kutoka django.utils.http kuagiza urlsafe_base64_encode, urlsafe_base64_decode kuagiza JSON Maombi ya kuagiza Ingiza wakati wa wakati, traceback Kutoka kwa Django.contrib Ujumbe wa kuagiza kutoka .Models Profaili ya kuagiza kutoka django.utils kuagiza saa ya saa kutoka django.views.decorators.cache kuagiza never_cache Kutoka kwa .email kuagiza send_verification_email # hakikisha kuagiza kazi ya kutuma barua pepe ya uthibitisho kutoka django.contrib.auth.decorators kuagiza login_required kutoka django.contrib.auth.mixins kuagiza loginRequiredMixin, mtumiajiSassSestMixin kutoka django.utils.decorators kuagiza njia_decorator kutoka django.http kuagiza httpresponserEdirect Kutoka kwa mipangilio ya kuagiza ya Django.conf kutoka django.utils kuagiza saa ya saa kuagiza wakati wa tarehe kuagiza pytz kutoka django.views.decorators.csrf kuagiza csrf_exempt kutoka django.http kuagiza httpresponse kutoka django.contrib.auth.Tokens kuagiza default_token_generator kutoka django.utils.http kuagiza urlsafe_base64_decode kutoka .tokens kuagiza akaunti_activation_token

Hakikisha kuagiza kazi ya kutuma barua pepe ya uthibitisho

Unaweza tayari kuwa na uagizaji huu, lakini hainaumiza kuirudia. Utahitaji kuingiza kazi ya kutuma barua pepe ya uthibitisho, na vile vile akaunti_activation_token kutoka kwa watumiaji.Tokens, kati ya uagizaji mwingine.

Sasa, chini ya faili, ongeza nambari ifuatayo:

DEF kujiondoa (ombi, jina la mtumiaji, ishara): Mtumiaji = Get_object_or_404 (mtumiaji, jina la mtumiaji = jina la mtumiaji) ikiwa ((ombi.user.is_authentized and ombi.user == mtumiaji) au mtumiaji.profile.check_token (ishara)): # Waandikishe wasifu = mtumiaji.profile Profaili.Subscribed = Uongo wasifu.save () Rudisha kutoa (ombi, 'watumiaji/kujiondoa.html')) # Vinginevyo uelekeze ukurasa wa kuingia Ujumbe.warning (ombi, kiungo cha kujiondoa kimeisha. Tafadhali ingia ili ujiondoe. ') Next_url = reverse ('Watumiaji: Jisajili', Kwargs = {'jina la mtumiaji': jina la mtumiaji, 'ishara': ishara,}) Rudisha httpResponseReDirect ('%s? Ijayo =%s'%(reverse ('logi'), Next_url)) DEF ACCICTION (Ombi, UIDB64, Ishara): jaribu: uid = nguvu_str (urlsafe_base64_decode (UIDB64)) mtumiaji = mtumiaji.objects.get (pk = uid) Isipokuwa (TypeError, Thamani ya Thamani, OverflowerRor, Mtumiaji.doesNotExist): mtumiaji = hakuna ip = kupata_client_ip (ombi) Ikiwa mtumiaji sio na ACCOUNT_ACTIVATION_TOKEN.CHECK_TOKEN (mtumiaji, ishara): mtumiaji.profile.email_verized = kweli mtumiaji.profile.save () mtumiaji.save () # sendwelcomeemail (ombi, mtumiaji) Ujumbe.Success (Ombi, F'Thanks za Kuthibitisha Barua pepe yako! Sasa unaweza kuingia kwenye akaunti yako, na barua pepe ya kukaribisha imetumwa kwako. ') Rudisha uelekeze (mtumiaji.profile.create_face_url ()) mwingine: Ujumbe.Success (Ombi, Kiungo cha Uanzishaji cha F'Your kimeisha. Tafadhali omba kiunga kipya cha uanzishaji. ') Rudisha uelekeze ('Thibitisha: Thibitisha') def resend_activation (ombi): Ikiwa ombi.method == 'chapisho': fomu = resendactivationMailForm (ombi.post) barua pepe = ombi.post ['barua pepe'] jaribu: mtumiaji = mtumiaji.objects.get (barua pepe = barua pepe) send_verification_email (mtumiaji) Ujumbe.Success (ombi, 'Barua pepe yako ya uthibitisho imetumwa. Tafadhali bonyeza kiungo kwenye barua pepe yako ili kuthibitisha akaunti yako.') Rudisha uelekeze (reverse ('Thibitisha: thibitisha')) isipokuwa: ujumbe.warning (ombi, barua pepe yako sio sahihi. Tafadhali jaribu tena. ') mwingine: fomu = resendactivationMailForm () kurudi kutoa (ombi, 'watumiaji/resend_activation.html', {'fomu': fomu, 'kichwa': 'rejesha uanzishaji', 'ndogo': kweli})

Waandikishe
        username = request.POST['username'] # Vinginevyo uelekeze ukurasa wa kuingia
        password = request.POST['password'] # SendWelceMemail (ombi, mtumiaji)
Hii ni nambari nyingi. Wacha tuivunja. Kazi ya kwanza, safi na rahisi, haifungui mtumiaji kutoka kwenye orodha ya barua. Kazi ya pili inaamsha barua pepe yao, na utagundua nimeongeza kazi iliyotolewa, SendWelComeemail. Unakaribishwa kutumia template ya barua pepe na ufafanuzi wa kazi kutuma barua pepe ya kuwakaribisha, bado sijapata. Kazi ya mwisho ambayo nilitupa ni muhimu, kwa sababu barua pepe za uanzishaji zinaisha. Kwa hivyo, tutahitaji kurudisha barua pepe ya uanzishaji wakati fulani. Tunaweza kutumia fomu ya msingi kwa hii, na piga simu kazi kutuma barua pepe ya uthibitisho. Kabla ya kufanya hivyo, wacha tuhakikishe inatumwa kwanza, kwa kuongeza simu ya kazi kwenye mtazamo wa usajili. Ongeza mstari huu kabla tu ya kuelekeza katika mtazamo wa usajili, usajili wa DEF, katika watumiaji/maoni.py.

watumiaji wa nano/maoni.py

#… (Baada) kujiandikisha (ombi): send_verification_email (mtumiaji) #… (Kabla) kuelekeza (
mkdir users/templates
mkdir users/templates/users
… (Baada) kujiandikisha (ombi):

… (Kabla) kuelekeza (

Huna haja ya kuongeza mistari ya kwanza na ya mwisho kwenye snippet ya nambari hiyo, hakikisha tu mtazamo wa usajili hutuma barua pepe ya uthibitisho kwa mtumiaji. Inapaswa kuonekana kama hii:
nano users/templates/users/login.html
#… Uagizaji kutoka .Forms kuagiza mtumiajiRegisterForm Usajili wa DEF (ombi): Ikiwa ombi.method == "chapisho": fomu = mtumiajiRegisterForm (ombi.post) ikiwa fomu.is_valid (): mtumiaji = fomu.save () SEND_VERIFICATION_EMAIL (mtumiaji) # Hakikisha kuongeza mstari huu! Ujumbe.Success (Ombi, 'Karibu kwenye programu, {}.'. (Mtumiaji.username)) Rudisha kutoa (ombi, 'watumiaji/rejista.html', {'fomu': mtumiajiRegisterForm})

… Uagizaji

Hakikisha kuongeza mstari huu!
Sasa, tutahitaji kuongeza fomu ili kurudisha barua pepe ya uanzishaji. Katika watumiaji/fomu.py, ongeza fomu ifuatayo:

#… (Uagizaji) darasa resendactivationmailform (fomu.form): barua pepe = fomu.emailfield (inahitajika = kweli)

… (Uagizaji)
Tutahitaji pia template inayolingana na fomu hii ya uanzishaji wa barua pepe. Wacha tuongeze templeti hii. Hariri faili:

Watumiaji wa Nano/templeti/watumiaji/resend_activation.html

Ifuatayo, ongeza nambari ifuatayo kwenye faili.
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']
{ % hupanua 'msingi.html' %} { % block yaliyomo %} { % mzigo crispy_forms_tags %} { % csrf_token %} Barua pepe ya uanzishaji {{fomu | crispy}} Barua pepe ya uanzishaji { % endblock %}

Whew, hiyo ni mengi! Sasa, tunapopeleka nambari kwenye seva yetu, tutaweza kutuma barua pepe ya HTML na kuamsha akaunti za watumiaji kwa kubonyeza kwenye barua pepe. Tunaweza pia kutaka kutuma barua pepe rahisi ya kuwakaribisha, kwa hivyo wacha tuone jinsi ya kufanya hivyo. Nyuma kwa watumiaji/barua pepe.py, ongeza nambari ifuatayo:

def sendwelcomeemail (mtumiaji): Mtumiaji = kupata_user_model () html = fungua ('{}/watumiaji/karibu_email.html'.format (mipangilio.base_dir). Soma () somo = 'karibu' + mipangilio.site_name + ', {{jina la mtumiaji}}!' template = template (html) subjtemplate = template (mada) muktadha = muktadha ({'jina la mtumiaji': mtumiaji.username, 'base_url': mipangilio.base_url, 'modeli_name': 'daisy holton,' tovuti_name ': mipangilio.site_name}) rereredTemplate = template.render (muktadha) SubJContext = muktadha ({'jina la mtumiaji': mtumiaji.username}) subjRenderedTemplate = subjtemplate.render (subjContext) send_html_email (mtumiaji, subjrenderedTemplate, rendedTemplate)

Pia, tutahitaji templeti kutoa habari hii yote. Kwenye wavuti yangu, templeti inaonekana kama hapa chini, lakini unakaribishwa kuibadilisha hata hivyo.

Karibu kwenye {{tovuti_name}} Hello {{jina la mtumiaji}}, Tunafurahi kukuona hapa! Asante kwa kujiunga na {{tovuti_name}} na kuwa sehemu ya raha. Ili kuanza, hapa kuna vitu vichache unaweza kufanya baada ya kuthibitisha kitambulisho chako. Tumia programu. Hii ndio ukurasa kuu wa {{tovuti_name}} Tembelea wasifu wangu wa kibinafsi {{tovuti_name}}. Hii ni ukurasa kwa mtu yeyote anayetaka kunijua. Profaili zaidi. Unaweza kupata watu hawa kwenye wavuti, na kuona yaliyomo. Tazama machapisho yote hapa. Hii ndio ukurasa wa mbele wa {{tovuti_name}}. Kuna zaidi kwenye wavuti, kwa hivyo jisikie huru kutembelea na uone kile unachopata. Unaweza kushiriki tovuti na vifungo vyovyote vya kijamii kwenye kila ukurasa. Natumahi unafurahiya wakati wako na {{tovuti_name}}! Asante kwa kuwa hapa. Kwa upendo mwingi, {{modeli_name}} {{base_url}}
# Kumbuka kuwa hatuna vitambulisho vya mwili au HTML, kwa sababu tunaongeza hizi wakati tunapoongeza kiunga cha HTML Kujiondoa. Hizi ni muhimu, lakini hatutaki kufafanua mara mbili.
Kwa hivyo ni nini kinachofuata? Tumetoka mbali. Kweli, tunapaswa kuwa tayari kupeleka tovuti kwa seva. Tunaweza kuongeza mapambo ya @login_required na kufanya maoni yetu kuwa salama, chukua saini za watumiaji, tuma barua pepe inayofuata, na habari ya kache, ambayo ni msingi wa kile tovuti inahitaji kufanya ili kuendelea kuwa sawa. Tutaongeza huduma kadhaa muhimu zaidi, na kisha kujenga msingi wa kupeleka nambari yetu kwa seva ya mbali, kuanzisha seva ya barua, usanidi wa kikoa, na vichungi ili kufanya tovuti yetu iwe salama na inafaa.

Tutahitaji pia mtazamo wa kuweka upya nywila, kwa hivyo wacha tuongeze hiyo haraka sana. Django imejengwa katika mtazamo wa kuweka upya nywila imevunjwa katika kazi zingine, lakini tutaangalia jinsi ya kuandika maoni yetu wenyewe, template ya barua pepe, fomu, na mifumo ya URL. Hapa kuna maoni yanaonekana, katika watumiaji/maoni.py

#... uagizaji kutoka django.contrib.auth.Tokens kuagiza default_token_generator kutoka django.contrib.auth.Forms kuagiza setpasswordform kutoka django.utils.http kuagiza urlsafe_base64_decode def password_reset (ombi, UIDB64, ishara): Mtumiaji = Get_object_or_404 (mtumiaji, id = urlsafe_base64_decode (UIDB64)) Ikiwa ombi.method == 'chapisho': fomu = setPasswordform (mtumiaji, ombi.post) ikiwa fomu.is_valid () na default_token_generator.check_token (mtumiaji, ishara): form.save () Ujumbe.Success (ombi, 'Nenosiri lako limewekwa upya.') elif sio fomu.is_valid (): ujumbe.warning (ombi, 'nywila zako hazilingani, au hazifikii mahitaji. Tafadhali jaribu tena.') Rudisha kuelekeza (ombi.path) mwingine: Ujumbe.warning (ombi, 'Kiunga chako cha kuweka upya nywila kimeisha. Tafadhali unda mpya.') Rudisha uelekeze (reverse ('watumiaji: kuingia')) Rudisha kutoa (ombi, 'watumiaji/password_reset_confirm.html', { 'Kichwa': 'Rudisha nywila yako', 'Fomu': setPasswordform (mtumiaji)
from django.db import models # ... Uagizaji
    author = models.ForeignKey(User, on_delete=models.CASCADE, null=True, blank=True, related_name='posts') # Njia hii imejengwa kwa Django, lakini tutahitaji templeti ili kudhibitisha upya nenosiri, watumiaji/templeti/watumiaji/nywila_reset_confirm.html
{ % hupanua 'msingi.html' %} { % mzigo crispy_forms_tags %} { % block yaliyomo %} { % csrf_token %} Rudisha nywila {{fomu | crispy}} Rudisha nywila { % endblock yaliyomo %}

Pia tunayo templeti ya kutuma barua pepe ya kuweka upya nywila, na fomu rahisi, katika watumiaji/templeti/watumiaji/nenosiri_reset.html

{ % hupanua 'msingi.html' %} { % mzigo crispy_forms_tags %} { % block yaliyomo %} { % csrf_token %} Rudisha nywila {{fomu | crispy}} Omba upya nywila { % endblock yaliyomo %}

Kiolezo cha barua pepe yenyewe ni rahisi, ni faili ya msingi ya HTML inayotoa kiunga cha kuweka upya nywila, katika watumiaji/templeti/watumiaji/nenosiri_reset_email.html. Django itatafsiri faili hii kiotomatiki.

Uglek - Rudisha nywila yako Hello, Ili kuweka upya nywila yako, tafadhali bonyeza hapa. Vinginevyo, unaweza kubandika kiunga kifuatacho kwenye kivinjari chako: https://uglek.com { % url 'password_reset_confirm' uidb64 = uid token = ishara %} Ikiwa haujaomba kuweka upya nywila unaweza kupuuza tu barua pepe hii. Asante kwa kujiunga nasi, Daisy
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='')
Tutahitaji pia templeti mbili zaidi. Ya kwanza ni kudhibitisha kuwa barua pepe imetumwa. Maoni ya haya tayari yapo Django, kwa hivyo tunahitaji tu kushughulikia kwenye URLS.Py. Kiolezo hiki kiko kwa watumiaji/templeti/watumiaji/password_reset_done.html

{ % hupanua 'msingi.html' %} { % block yaliyomo %} Barua pepe imetumwa na maagizo ya kuweka upya nywila yako. { % endblock yaliyomo %}

Na mwishowe, ili kudhibitisha kuwa kuweka upya nywila kukamilika, watumiaji/templeti/watumiaji/nywila_reset_complete.html

{ % hupanua 'msingi.html' %} { % block yaliyomo %} Nenosiri lako limewekwa. Ingia hapa { % endblock yaliyomo %}

Sasa, tunahitaji mifumo ya URL kwa maoni haya. Katika watumiaji/urls.py, ongeza mifumo ifuatayo ya URL:
# urlpatterns = [
    #... URL zilizopita hapa
    njia ('nywila-reset/',
         Author_views.passwordresetview.as_view (
             template_name = 'watumiaji/password_reset.html',
             html_email_template_name = 'watumiaji/nywila_reset_html_email.html'
         ),
         jina = 'password_reset'),
    njia ('nywila-reset/imekamilika/',
         Author_views.passwordresetdoneview.as_view (
             template_name = 'watumiaji/password_reset_done.html'
         ),
         jina = 'password_reset_done'),
    njia ('nenosiri-reset-confirm ///',
         Author_views.passwordresetconfirmview.as_view (
             template_name = 'watumiaji/nenosiri_reset_confirm.html'
         ),
         jina = 'password_reset_confirm'),
    njia ('nenosiri-kamili-kamili/',
         Author_views.passwordresetCompleteView.as_view (
             template_name = 'watumiaji/password_reset_complete.html'
         ),
         Jina = 'password_reset_complete'),
]
            Profile.objects.create(user=user) # ... URL zilizopita hapa
Templeti nne, hiyo ni mengi! Lakini sasa tunaweza kuwa na hakika kuwa na uwezo wa kuweka upya nywila ya mtumiaji wakati wowote tunahitaji, yote kutoka kwa kivinjari cha wavuti.

Ninaelewa hii ni nambari nyingi. Ikiwa inaonekana kidogo juu ya kichwa chako, hiyo ni sawa. Utaboresha, uelewa wako utaboresha, na utakuwa na uwezo zaidi na nambari hivi karibuni. Ikiwa umepotea kabisa, napendekeza kurudi kwenye programu hii baadaye baada ya kufanya kazi ya kujishughulisha kujifunza kozi mkondoni. Hizi kawaida ni bure kuanza, na zitakuongoza kupitia kila kitu unahitaji kufanikiwa unaporudi kwenye mradi huu. Ikiwa unahisi kama uko tayari kuendelea, soma, ijayo, tutashughulikia kupeleka nambari yako kwa seva ya mbali na kusanidi seva ya barua, na pia kuelekeza kupelekwa kwako kwa kutumia bash ili uweze kusanidi mradi mpya na amri rahisi chache.

Jambo la mwisho tunahitaji kufanya kabla ya kupeleka kwa seva ya mbali ni kufanya tovuti yetu iwe salama zaidi. Utagundua kuwa mtazamo wa kuingia huchukua tu jina la mtumiaji na nywila, na hakuna uthibitisho wa sababu nyingi au nambari ya wakati mmoja. Hii ni kurekebisha rahisi, na kwa nambari hiyo hiyo, tunaweza kufanya tovuti yetu kutuma ujumbe wa maandishi na hata kuwajibika kwa ujumbe wa maandishi uliotumwa kwa seva. Kuanza, tutarudi kwenye mifano ya watumiaji na kuongeza saini ya wakati ambayo itawakilisha kila kuingia. Pia tutaongeza kitambulisho cha kipekee, kinachozunguka kwa mfano wa mtumiaji ambacho kitatumika kuongeza usalama wa ziada kwenye kuingia kwetu. Kuhariri mifano ya watumiaji, watumiaji/modeli.py, ongeza nambari ifuatayo:
# Kutoka kwa mifano ya kuagiza ya Django.db.
kutoka django.contrib.auth.Models Mtumiaji wa kuagiza
kutoka django.utils kuagiza saa ya saa
# Hakikisha kuagiza UUID, Saini ya Timestamp na Jenereta ya URL (Reverse)
kuagiza uuid
kutoka django.core.Signing kuagiza timestampsigner, badsignature, sainiExpired
kutoka django.urls kuagiza reverse

Profaili ya darasa (modeli.model):
    Mtumiaji = Models.ToNoOneField (mtumiaji, on_delete = models.cascade, null = kweli, tupu = kweli, uhusiano_name = 'wasifu')
    Akaunti_created = Models.DateTimeField (chaguo -msingi = Timezone.Now)
    Last_seen = Models.DateTimeField (chaguo -msingi = Timezone.Now)
    can_login = models.dateTimeField (chaguo -msingi = timezone.now)
    prepared_name = models.charfield (max_length = 20, default = '', null = kweli, tupu = kweli)
    bio = models.TextField (tupu = kweli, chaguo -msingi = '')
    # Ongeza nambari hii hapa
    uid = models.charfield (max_length = 32, default = uuid.uuid4, null = kweli, tupu = kweli)
    mfA_Enured = models.booleanfield (chaguo -msingi = uongo)
    Wezesha_mfa = Models.booleanfield (chaguo -msingi = uongo)
    simu_number = models.charfield (chaguo -msingi = '', null = kweli, tupu = kweli, max_length = 15)
    uthibitisho_code = models.charfield (chaguo -msingi = '', null = kweli, tupu = kweli, max_length = 15)
    uthibitisho_code_length = models.IntegerField (chaguo -msingi = 6)
    MFA_CODE_EXPIRES = Models.DateTimeField (chaguo -msingi = Timezone.Now)
    MFA_ATTEMPTS = Models.IntegerField (chaguo -msingi = 0)

    def make_auth_token (ubinafsi):
        Rudisha timestampsigner (). ishara (self.uid)

    # Na ongeza kazi hii
    def kuunda_auth_url (ubinafsi):
        jina la mtumiaji, ishara = self.make_auth_token (). mgawanyiko (":", 1)
        kurudi nyuma ('Watumiaji: MFA', Kwargs = {'jina la mtumiaji': jina la mtumiaji, 'ishara': ishara,})

    def check_auth_token (ubinafsi, ishara):
        jaribu:
            ufunguo = '%s:%s'%(self.uid, ishara)
            TimeStampSigner (). Unsign (ufunguo, max_age = 60 * mipangilio.auth_valid_minutes) # halali kwa dakika 3
        isipokuwa (badsignature, sainiExpired):
            kurudi uwongo
        Rudi kweli
        if user and user.profile.can_login < timezone.now(): # Hakikisha kuagiza UUID, Saini ya Timestamp na Jenereta ya URL (Reverse)
        else: # Ongeza nambari hii hapa
            user = User.objects.filter(username=username).first() # Na ongeza kazi hii
                profile.can_login = timezone.now() + datetime.timedelta(seconds=15) # Halali kwa dakika 3
Hakikisha watumiaji wako/modeli.py inaonekana kama hii, mbali na maoni (nambari kwenye mistari na #). Kuvunja hii, ni rahisi. Tunayo uagizaji machache, timestampsigner ambayo ni matumizi ya cryptographic ambayo inaweza kutoa nambari salama na kuithibitisha ili kuhakikisha kuwa ni halali, imetumika mara moja tu, na sio mzee kuliko idadi fulani ya sekunde. Tunatumia pia UUID, ambayo ni kitambulisho cha kipekee ambacho kinamtambulisha mtumiaji wetu katika kusainiwa kwa ishara, na katika URL ambayo ishara hutumwa kwa mtumiaji. Tutatumia maandishi haya ya msingi kujenga mtazamo wa uthibitishaji wa sababu mbili. Kabla ya kufanya kitu kingine chochote, wacha tuendesha uhamiaji ili mifano yetu ya watumiaji isasishwe. Kwenye saraka na Usimamizi.py, endesha amri zifuatazo za kufanya na kukamilisha uhamiaji.

Chanzo Venv/bin/actishate Python Management.py Makemigrations && Python Usimamizi.py kuhamia

Hii ni muhimu kwa sababu kila wakati tunapofanya mabadiliko kwa mifano, tutahitaji kuunda meza na kusasisha hifadhidata na defaults kabla ya kutumia mifano.

Ifuatayo, wacha tuboresha mtazamo wetu wa kuingia ili kuelekeza kwa mtazamo wa uthibitishaji wa sekondari. Katika watumiaji/maoni.py, ondoa kazi ya kuingia na uelekeze kwa URL ambayo tumetengeneza tu kwenye mifano ya watumiaji.

#… Uagizaji def kuingia (ombi): Ikiwa ombi.method == "chapisho": jina la mtumiaji = ombi.post ['jina la mtumiaji'] nywila = ombi.post ['nywila'] Mtumiaji = thibitisha (jina la mtumiaji = jina la mtumiaji, nywila = nywila) Ikiwa mtumiaji na mtumiaji.profile.can_login <timezone.now (): # kumbuka kuwa sasa tunaangalia ikiwa mtumiaji anaweza kuingia # Ondoa kazi ya Author_Login ambayo ilikuwa hapa Ujumbe.Success (ombi, 'Nenosiri lako lilikubaliwa. Tafadhali endelea.') Ikiwa mtumiaji.profile.mfa_enured: Rudisha uelekeze (mtumiaji.profile.create_auth_url ()) # Kumbuka tunaelekeza URL mpya hapa Vinginevyo: # Ikiwa mtumiaji hatumii uthibitishaji wa sababu ya mutli, ingia tu. AUTH_Login (ombi, mtumiaji, backend = 'django.contrib.auth.backends.modelbackend') Rudisha uelekeze ('kulisha: kulisha') mwingine: # ikiwa kuingia hakufanikiwa, ujumbe.warning (ombi, 'jina la mtumiaji au nywila sio sahihi. Tafadhali jaribu tena.') mtumiaji = mtumiaji.objects.filter (jina la mtumiaji = jina la mtumiaji) .first () # hii ndio sehemu ambayo tunasasisha wasifu wa watumiaji Ikiwa mtumiaji: wasifu = mtumiaji.profile wasifu.can_login = timezone.now () + dateTime.timedelta (sekunde = 15) # kwa hivyo hawawezi kuingia tena kwa sekunde chache wasifu.save () Rudisha kutoa (ombi, 'watumiaji/login.html', {'fomu': uthibitishajiForm ()})
sudo backup
… Uagizaji

Kumbuka kuwa sasa tunaangalia ikiwa mtumiaji anaweza kuingia

Ondoa kazi ya Author_Login ambayo ilikuwa hapa
sudo crontab -e
Kumbuka tunaelekeza URL mpya hapa

Ikiwa mtumiaji hatumii uthibitisho wa sababu nyingi, ingia tu.

Ikiwa kuingia hakufanikiwa,
0 * * * * sudo backup
Hii ndio sehemu ambayo tunasasisha wasifu wa watumiaji

Kwa hivyo hawawezi kuingia tena kwa sekunde chache

Kwa hivyo hii ni rahisi sana, sasa tunayo njia ya kuelekeza mtazamo wa uthibitishaji wa sababu mbili tunapounda. Sisi pia tunayo kurudi nyuma ikiwa mtumiaji hajaongeza nambari ya simu. Tutaongeza mtazamo wa msingi kuongeza nambari ya simu hivi karibuni na kuingia na ujumbe wa maandishi hivi karibuni.

Kwanza, tunahitaji njia rahisi ya kutuma ujumbe wa maandishi kutoka kwa nambari yetu. Ili kufanya hivyo, tunaweza kuchagua kutoka kwa API kadhaa, lakini rahisi zaidi kwa maoni yangu ni Twilio. Pia hutoa bei nzuri kwa miradi midogo, na vile vile punguzo la wingi. Unda akaunti kwenye Twilio.com, jaza maelezo kadhaa juu ya mradi wako, nunua nambari ya simu, na unakili funguo zako za API kwa mipangilio yako.py. Halafu, ongeza nambari hii chini ya faili mpya, watumiaji/sms.py.

Watumiaji wa Nano/sms.py
sudo visudo
# Ingiza vifurushi vyote muhimu kutoka django.utils kuagiza saa ya saa Ingiza nasibu kuagiza wakati wa tarehe Kutoka kwa mipangilio ya kuagiza ya Django.conf kutoka kwa feed.Middleware kuagiza kupata_current_request Kutoka kwa Django.contrib Ujumbe wa kuagiza kuagiza traceback Account_sid = Mipangilio.twilio_account_sid AUTH_TOKEN = mipangilio.twilio_auth_token Source_Phone = Mipangilio.Phone_Number # Nambari hii hutuma maandishi na Twilio def send_text (lengo_phone, maandishi): Kutoka kwa Twilio.Rest Mteja wa kuagiza jaribu: Mteja = Mteja (Akaunti_sid, Author_Token) Ikiwa len (lengo_phone)> = 11: ujumbe = mteja.messages.create ( to = lengo_phone, Kutoka_ = chanzo_phone, mwili = maandishi) isipokuwa: Chapisha (traceback.format_exc ()) # Kazi ya msaidizi kupata nambari na nambari nyingi def kupata_num_length (nambari, urefu): n = '' Kwa x katika anuwai (urefu): n = n + str (num) Rudisha int (n) # Tuma maandishi ili kuthibitisha mtumiaji def send_verification_text (mtumiaji): urefu = mtumiaji.profile.verification_code_length nambari = nasibu.randint (Get_num_length (1, urefu), Get_num_length (9, urefu)); mtumiaji.profile.verification_code = nambari mtumiaji.profile.mfa_code_expires = timezone.now () + dateTime.timedelta (dakika = 3) mtumiaji.profile.save () send_user_text (mtumiaji, "nambari yako ya uthibitisho wa {} ni {}". (Mipangilio.site_name, str (nambari))) # Tuma mtumiaji maandishi yoyote na kazi hii def send_user_text (mtumiaji, maandishi): send_text (mtumiaji.profile.phone_number, maandishi) # Thibitisha nambari na kazi hii def check_verification_code (mtumiaji, nambari): mtumiaji.profile.mfa_attempts += 1 matokeo = mtumiaji.profile.verification_code! = Hakuna na nambari! = '' na mtumiaji.profile.verification_code == msimbo na mtumiaji.profile.mfa_code_expires> timezone.now () na mtumiaji.profile.mfa_attempts <= 3 Ikiwa mtumiaji.profile.mfa_attempts <3 na matokeo: mtumiaji.profile.verification_code_length = 6 elif mtumiaji.profile.mfa_attempts> 2 na sio matokeo: mtumiaji.profile.verification_code_length = 8 mtumiaji.profile.save () matokeo ya kurudi # Thibitisha wakati def check_verification_time (mtumiaji): matokeo = mtumiaji.profile.mfa_code_expires> timezone.now () matokeo ya kurudi

Ingiza vifurushi vyote muhimu

Nambari hii hutuma maandishi na Twilio
ALL ALL=NOPASSWD: /bin/backup
Kazi ya msaidizi kupata nambari na nambari nyingi

Tuma maandishi ili kuthibitisha mtumiaji

Tuma mtumiaji maandishi yoyote na kazi hii

Thibitisha nambari na kazi hii

Thibitisha wakati

Hakikisha kubadilisha mipangilio yako ipasavyo, na kuongeza mistari hii na funguo zako:

# Hakikisha kunakili hizi kutoka kwa dashibodi yako ya Twilio Twilio_account_sid = "" Twilio_auth_token = "" Simu_number = "" Tovuti_name = "" AUTH_VALID_MINUTES = 3 # Idadi ya dakika ukurasa wa TFA unatumika mara moja

Hakikisha kunakili hizi kutoka kwa dashibodi yako ya Twilio

Idadi ya dakika ukurasa wa TFA unatumika mara moja

Kwanza, tutahitaji fomu kwa maoni yetu ya uthibitisho wa sababu mbili. Kuhariri watumiaji/fomu.py, ongeza nambari ifuatayo.

#… Uagizaji kutoka kwa fomu za kuagiza Django # Fomu ya kuingiza nambari yetu ya simu Darasa la phoneNumberForm (fomu.form): simu_number = fomu.Regexfield (regex = r '^\+? 1? def __init __ (ubinafsi, *args, ** Kwargs): super (phonenumberform, kibinafsi) .__ init __ (*args, ** Kwargs) self.fields ['simu_number']. lebo = simu_number_label # Fomu ya kudhibitisha darasa TFAFORM (fomu.form): nambari = fomu.IntegerField (inahitajika = uongo) def __init __ (ubinafsi, *args, ** Kwargs): super (tfaform, kibinafsi) .__ init __ (*args, ** Kwargs) self.fields ['code']. widget.attrs.update ({'autocomplete': 'off'}) msaada_texts = { 'Code': 'Tafadhali ingiza nambari sita ya nambari baada ya kuipeleka kwa simu yako na kitufe hapo juu.' }
nano app/settings.py
… Uagizaji

Fomu ya kuingiza nambari yetu ya simu

Fomu ya kudhibitisha

Ifuatayo, wacha tuunda maoni katika watumiaji/maoni.py

#… Uagizaji kutoka django.http kuagiza httpresponserEdirect kutoka .Forms kuagiza phonenumberform, tfaform DEF MFA (ombi, jina la mtumiaji, ishara): mtumiaji = mtumiaji.objects.filter (wasifu__uuid = jina la mtumiaji) .First () ikiwa sio mtumiaji: rudisha httpResponseRedIrect (reverse ('thibitisha: umri') + '? ijayo =' + ombi.get.get ('ijayo') ikiwa ombi.get.get ('ijayo') mwingine '/go/' ikiwa ombi.user.is_authentied and reose.user.profile.Vendor else '/ Mtumiaji = Get_object_or_404 (mtumiaji, Profaili__Uuid = Jina la mtumiaji) Ifuatayo = ombi.get.get ('ijayo', '') Ikiwa sio mtumiaji.profile.mfa_enured: Ikiwa sio Check_verification_time (mtumiaji): mtumiaji.profile.mfa_enured = uongo mtumiaji.profile.enable_two_factor_authentication = kweli mtumiaji.profile.phone_number = '+1' mtumiaji.profile.save () Chapisha ('Kuingia kwa Mtumiaji') AUTH_Login (ombi, mtumiaji, backend = 'django.contrib.auth.backends.modelbackend') ujumbe.warning (ombi, 'Tafadhali ingiza nambari halali ya simu na uhakikishe na nambari.') Rudisha uelekeze (reverse ('Watumiaji: MFA_onboarding')) Ikiwa ombi.method == 'chapisho': fomu = tfaform (ombi.post) nambari = fomu.data ['msimbo'] Ikiwa nambari na nambari! = '' na nambari! = Hakuna: token_validated = mtumiaji.profile.check_auth_token (ishara) p = mtumiaji.profile is_verized = check_verification_code (mtumiaji, int (nambari)) p.mfa_authentied = is_verized Ikiwa token_validated: Ikiwa imekadiriwa: mtumiaji.profile.mfa_enured = kweli mtumiaji.profile.save () AUTH_Login (ombi, mtumiaji, backend = 'django.contrib.auth.backends.modelbackend') P.VERFICATION_CODE = hakuna p.uid = kupata_uuid () P.Save () Ujumbe.Success (Ombi, 'Umethibitishwa. Karibu.') QS = '?' Kwa ufunguo, thamani katika ombi.get.items (): QS = QS + Key + '=' + Thamani + '&' Ikiwa ijayo! = '' na sio (Next.StartSwith ('/Akaunti/logout/') au Next.StartSwith ('/Akaunti/kuingia/') au Next.StartSwith ('/admin/logi/') au Next.Startswith ('/Akaunti/Usajili/'):): Rudisha HttpResponseReDirect (ext) elif ijayo.startswith ('/akaunti/logout/') au ijayo.startswith ('/akaunti/kuingia/') au ijayo.startswith ('/akaunti/rejista/'): Rudisha uelekeze ('kulisha: kulisha') ombi la elif.meta.get ('http_referer', '/').startswith('/accounts/login/'): Rudisha uelekeze (reverse ('kulisha: kulisha')) Elif sio ijayo: Rudisha uelekeze (reverse ('kulisha: kulisha') mwingine: Rudisha HttpResponseReDirect ('Kulisha: Kulisha') mwingine: Ujumbe.warning (ombi, 'Nambari uliyoingiza haikutambuliwa. Tafadhali jaribu tena.') elif sio ishara_validated: Ujumbe.warning (ombi, 'Ishara ya URL imekwisha au haikutambuliwa. Tafadhali jaribu tena.') Kuingia (ombi) Rudisha uelekeze (reverse ('watumiaji: kuingia')) Ikiwa p.mfa_attempts> 3: Ujumbe.warning (ombi, 'umeingiza nambari isiyo sahihi zaidi ya mara 3. Tafadhali tuma nambari mpya.') P.Verification_code = hakuna P.Save () elif mtumiaji.profile.can_send_mfa <timezone.now (): mtumiaji.profile.mfa_attempts = 0 mtumiaji.profile.can_send_mfa = timezone.now () + tareheTime.timedelta (dakika = 2) mtumiaji.profile.save () send_verification_text (mtumiaji) Ujumbe.Success (ombi, "Tafadhali ingiza nambari iliyotumwa kwa nambari yako ya simu. Nambari itaisha kwa dakika 3.") mwingine: ujumbe.warning (ombi, 'unatuma nambari nyingi za uthibitisho wa sababu mbili. Subiri dakika chache kabla ya kutuma nambari nyingine.') fomu = tfaform () kujificha_logo = hakuna Ikiwa mtumiaji.profile.hide_logo: kujificha_logo = kweli Rudisha utoaji (ombi, 'watumiaji/mfa.html', {'kichwa': 'ingiza nambari', 'fomu': fomu, 'xsmall': kweli, 'mtumiaji': mtumiaji, 'ficha_logo': ficha_logo, 'accl_logout': mtumiaji.profile.shake_to_logout, 'preload': FALSE vyi @login_required def MFA_onboarding (ombi): Ikiwa ombi.method == 'chapisho': fomu = phoneNumberForm (ombi.post) ombi.user.profile.phone_number = form.data ['simu_number']. Badilisha ('-', '') .replace ('(', ''). Badilisha (')', '') ombi.user.profile.mfa_enured = kweli ombi.user.profile.enable_two_factor_authentication = kweli ombi.user.profile.save () Ujumbe.Success (ombi, 'Umeongeza nambari ya simu kwenye akaunti yako.') mtumiaji = ombi.user Rudisha uelekeze (mtumiaji.profile.create_auth_url ())Fomu = PhoneNumberForm (Awali = {'Simu_Number': ombi.user.profile.phone_number ikiwa ombi.user.profile.phone_number nyingine '+1'}) kurudi kutoa (ombi, 'watumiaji/mfA_onboarding.html', {'kichwa': 'Ingiza nambari yako ya simu', 'fomu': fomu, 'ndogo':
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)
… Uagizaji

Tutahitaji pia templeti kwa maoni haya yote mawili. Wacha tuongeze templeti ya MFA kwanza.

Watumiaji wa Nano/templeti/watumiaji/mfa.html
import os
import json
with open('/etc/config.json') as config_file:
    config = json.load(config_file)
Ongeza nambari hii ya HTML kwenye template

{ % hupanua 'msingi.html' %} { % block yaliyomo %} { % mzigo programu_filters %} { % mzigo crispy_forms_tags %} { % csrf_token %} Ingiza nambari ya uthibitisho Hatua ya 1: Tuma nambari Kamwe usishiriki nambari yako na mtu yeyote, kwani inaweza kutumika kupata akaunti yako kwa muda. Tuma nambari Hatua ya 2: Ingiza nambari {{fomu | crispy}} Bonyeza kitufe cha ENTER ili ujitumie nambari kwa {{mtumiaji.profile.phone_number | Salama ya simu}}. Kisha, ingiza nambari na bonyeza Enter. Ingiza nambari { % endblock %}

Hii ni nzuri ya kujielezea. Fomu hutuma nambari au nambari tupu, na utagundua kwa mtazamo tunatuma nambari ikiwa tutapokea nambari tupu. Halafu tunayo vifungo viwili tu, na kwa njia hii tunaweza kutuma nambari na kitufe chochote. Ifuatayo, tutaongeza fomu rahisi kuongeza nambari ya simu.

Watumiaji wa Nano/templeti/watumiaji/MFA_onboarding.html

Ongeza HTML ifuatayo:
sudo nano /etc/config.json
{ % hupanua 'msingi.html' %} { % block yaliyomo %} { % mzigo crispy_forms_tags %} { % csrf_token %} Sanidi uthibitisho wa sababu mbili {{fomu | crispy}} Ongeza nambari ya simu { % endblock %}

Njia hii ni rahisi sana, inapeana fomu ya nambari ya simu ambayo tumeunda na kumruhusu mtumiaji kuongeza nambari ya simu.

Hii inaonekana nzuri sana! Kwa muda mrefu kila kitu kimewekwa vizuri, tunapaswa kuwa na uwezo wa kutuma ujumbe, na kuingia kwa mtumiaji na nambari yao ya simu mara tu tunapoongeza mifumo ya URL. Jambo la mwisho tunahitaji kuanzisha ni mtazamo wa wasifu ili tuweze kuhakikisha kuwa mtumiaji anaweza kubadilisha nambari yao ya simu bila kuingia. Pia, mwishowe tutataka kuongeza chaguo la "kuacha kuacha", kwa hivyo mtumiaji anaweza maandishi "kuacha" kuchagua ujumbe wa maandishi wa baadaye.
{
	"EMAIL_HOST_PASSWORD": "<some password here>"
}
Wacha tuongeze mtazamo wa wasifu kwa watumiaji/maoni.py. Mtazamo huu utasasisha bio ya mtumiaji, barua pepe, jina la mtumiaji, na nambari ya simu, na pia kuturuhusu kuwezesha uthibitisho wa sababu nyingi. Kwanza, tutahitaji aina mbili zaidi katika watumiaji/fomu.py

#... uagizaji USERUPDateForm ya darasa (fomu.modelform): Barua pepe = Fomu.EmailField () Darasa la Meta: mfano = mtumiaji shamba = ['jina la mtumiaji', 'barua pepe'] simu_number_label = 'nambari ya simu (hakuna nafasi, mabano \' (\ 'au dashes \'-\ ', nambari zinazoanza na + tu)' Class ProfailiUpDateForm (fomu.modelfOrm): Imesajiliwa = Fomu.BooLeanField (inahitajika = uongo) simu_number = fomu.charfield (inahitajika = uongo) def __init __ (ubinafsi, *args, ** Kwargs): Super (ProfailiUpdateForm, Ubinafsi) .__ init __ (*args, ** Kwargs) Darasa la Meta: mfano = wasifu shamba = ['bio', 'simu_number', 'Wezesha_mfa', 'imesajiliwa']

... Uagizaji
nano users/templates/users/verification_email.html
Ifuatayo, tunaweza kuunda mtazamo wa kutumia aina hizi zote mbili. Hariri watumiaji/maoni.py na ongeza kwenye mtazamo.
# Ongeza uagizaji huu Kutoka .Forms Ingiza USERUPDateForm, ProfailiUpDateForm kutoka django.views.decorators.cache kuagiza never_cache kutoka django.views.decorators.csrf kuagiza csrf_exempt kutoka .Models Profaili ya kuagiza kutoka .MFA kuagiza send_user_text @csrf_exempt @never_cache @login_required Profaili ya DEF (ombi): Ikiwa ombi.method == 'chapisho': u_form = userUpDateForm (ombi.post, mfano = ombi.user) p_form = ProfailiUpDateForm (ombi.post, ombi.Files, mfano = ombi.user.profile) ikiwa u_form.is_valid () na p_form.is_valid (): New_Phone_Number = p_form.data ['simu_number'] u_form.save () wasifu = p_form.save (ahadi = uongo) wasifu.phone_number = wasifu.phone_number.replace ('-', '') .replace ('(', ''). Badilisha (')', '') wasifu.save () Ikiwa New_Phone_Number! = OldProfile.Phone_Number na OldProfile.Phone_Number na Len (OldProfile.Phone_Number)> = 11: wasifu.mfa_enured = kweli wasifu.save () send_text (oldprofile.phone_number, 'Nambari yako ya simu imesasishwa kwa' + new_phone_number + '. Tafadhali rejelea maandishi kwenye simu hiyo ili uingie. Ikiwa haukufanya mabadiliko haya, tafadhali tupigie simu. - {}. (Mipangilio.site_name))) Ikiwa wasifu.enable_two_factor_authentication na wasifu.phone_number na len (wasifu.phone_number) <11: wasifu.enable_two_factor_authentication = uongo Ujumbe.Success (Ombi, Uthibitishaji wa F'two Factor unaweza kuamilishwa bila kuingiza nambari ya simu. Tafadhali ingiza nambari ya simu ili kuwezesha uthibitisho wa sababu mbili. ') wasifu.save () Ikiwa New_Phone_Number! = OldProfile.Phone_Number na New_Phone_Number na Len (New_Phone_Number)> = 11: send_user_text (ombi.user, 'Umeongeza nambari hii kwa {} kwa uthibitisho wa sababu mbili. Sasa unaweza kutumia nambari yako kwa uthibitisho wa sababu mbili. Ikiwa haukufanya mabadiliko haya, tafadhali tupigie simu. wasifu.mfa_enured = kweli Profaili.MFA_CODE_EXPIRES = Timezone.Now () + DateTime.timeDelta (dakika = 3) wasifu.save () Rudisha uelekeze (wasifu.create_auth_url ()) Ujumbe.Success (ombi, wasifu wako umesasishwa! ') Chapisha ('Profaili iliyosasishwa') Rudisha Uelekezaji ('Watumiaji: Profaili') mwingine: u_form = userUpDateForm (mfano = ombi.user) p_form = ProfailiUpDateForm (mfano = ombi.user.profile, awali = {'simu_number': ombi.user.profile.phone_number ikiwa ombi.user.profile.phone_number nyingine '+1'}) muktadha = { 'u_form': u_form, 'p_form': p_form, 'Kichwa': 'Sasisha wasifu wako', } Rudisha kutoa (ombi, 'watumiaji/wasifu.html', muktadha)

Ongeza uagizaji huu

Tutahitaji pia template ya maoni haya.
SITE_NAME = 'Django App'
PROTOCOL = 'https'
DOMAIN = 'example.com'

BASE_URL = PROTOCOL + '://' + DOMAIN
Watumiaji wa Nano/templeti/watumiaji/wasifu.html

{ % inapanua "msingi.html" %} { % mzigo crispy_forms_tags %} {% mzigo kulisha_filters%} { % block yaliyomo %} Hariri wasifu wako { % csrf_token %} Maelezo ya wasifu {{u_form | crispy}} {{p_form | crispy}} Sasisha} Imeokolewa { % endblock yaliyomo %} { % block javascript %} fomu ya var = hati.getElementById ('profaili-fomu'); $ ('pembejeo'). mabadiliko (kazi () { var formData = formData mpya (fomu); $ .Ajax ({ URL: windows.location.href, Aina: "Chapisha", Takwimu: FormData, processdata: uongo, Uzamili: Uongo, Muda: 1000 * 60, Mafanikio: kazi (data) { $ (imechapishwa) .removeclass ("ficha"); setTimeout (kazi () { $ (iliyotumwa) .Addclass ("fade iliyofichwa"); setTimeout (kazi () { $ (imechapishwa) .Addclass ("Ficha"); $ (imechapishwa) .removeclass ("fade iliyofichwa"); }, 2000); }, 2000); } }); }); { % endblock %}

Utagundua hii ni fomu rahisi, lakini ina JavaScript ndani yake ambayo inachapisha moja kwa moja yaliyomo kwenye fomu kama inavyosasishwa. Hii ni muhimu kuwa nayo, kwa hivyo una uwezo wa kufanya mabadiliko bila kulazimisha kuwasilisha kila wakati.

Ifuatayo, tunahitaji URL zinazowakilisha maoni haya yote kwenye viboreshaji vya URL ya watumiaji. Hariri watumiaji/urls.py na ongeza nambari hii:

#… Nambari ya zamani, uagizaji Kutoka kwa Django.urls njia ya kuagiza kutoka. maoni ya kuagiza app_name = 'watumiaji' urlpatterns = [ #… Mifumo ya URL ambayo tuliingia hapo awali, ongeza mistari mitatu ijayo Njia ('MFA ///', Views.MFA, Jina = 'MFA'), njia ('mfA/onboarding/', maoni.mfa_onboarding, jina = 'mfA_onboarding'), njia ('wasifu/', maoni.profile, jina = 'wasifu'), ]
nano users/tokens.py
… Nambari ya zamani, uagizaji

… Mifumo ya URL ambayo tuliingia hapo awali, ongeza mistari mitatu ijayo

Sasa ni wakati mzuri wa kujaribu mradi wetu. Lakini kwanza, wacha tuendesha nakala nyingine.
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()
chelezo

Na kukimbia seva. Kabla ya kupeleka kwa seva ya Linux, ni wazo nzuri kuwezesha uthibitisho wa sababu mbili kwenye akaunti. Tutafanya hivyo kwenda kwenye URL yetu ya wasifu,/watumiaji/wasifu/, na kuangalia kisanduku ili kuwezesha uthibitisho baada ya kuingiza nambari yetu ya simu, na kisha kuwasilisha fomu.

Python Management.py RunServer Localhost: 8000

Tembelea ukurasa wa wavuti kwa kwenda kwenye kivinjari chako cha wavuti, ninatumia Google Chrome katika mfano huu, na kuingia URL https: // localhost: 8000/akaunti/wasifu/

Utaweza kuingia ikiwa ni lazima na kuwezesha uthibitisho wa sababu mbili.
nano users/email.py
Mradi huu unahitaji seva iendelee ili iweze kutuma barua. Lakini kwanza, tunahitaji njia ya kuona makosa. Utagundua kuwa ikiwa unaendesha seva katika hali ya utatuzi, na Mipangilio.Debug Sawa na Ukweli, seva inaonyesha makosa moja kwa moja. Kuonyesha makosa bila kutumia hali ya utatuzi, ambayo sio salama kwenye seva ya uzalishaji, tunapaswa kuongeza maoni yake. Makosa muhimu zaidi ambayo tunahitaji kuweza kushughulikia ni:

Kosa 500 - Shida na nambari yetu Kosa 404 - Ukurasa ambao haukupatikana (URL iliyovunjika) Kosa 403 - ruhusa ilikataliwa kosa

Wacha tuongeze programu mpya kushughulikia makosa haya, inayoitwa makosa.
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)
Makosa ya Python Usimamizi.py

Ongeza hii kwa mipangilio.py kama tulivyofanya hapo awali, katika mpangilio wa kusanikishwa, na anza kwa kuongeza marejeleo ya maoni kadhaa katika programu/urls.py, ambapo programu ndio jina la mradi wako wa Django.

handler404 = 'makosa.views.handler404' handler500 = 'makosa.views.handler500' handler403 = 'makosa.views.handler403'
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()
Hii ndio yote tunayohitaji badala ya maoni ya makosa, templeti na kidogo ya middleware. Wacha tufafanue wale kama hivyo:

Kutoka kwa Django.Shortcuts kuagiza, kuelekeza kutoka django.http kuagiza httpresponse kutoka kwa StackTrace.Models Error Error kutoka kwa makosa.Middleware kuagiza kupata_current_exception kutoka django.contrib.auth.decorators kuagiza login_required kutoka django.contrib.auth.decorators kuagiza mtumiaji_pass_test kutoka .logs kuagiza kupata_logs kutoka kwa uso.Tests kuagiza ni_superuser_or_vendor kutoka django.views.decorators.csrf kuagiza csrf_exempt kutoka kwa makosa.Hightlight kuagiza Onyesha_code kutoka django.Shortcuts kuagiza kuelekeza kutoka django.urls kuagiza reverse # Unda maoni yako hapa. @login_required @user_pass_test (is_superuser_or_vendor) Magogo ya def (ombi): Magogo = onyesha_code (Get_logs ()) Rudisha kutoa (ombi, 'makosa/live_error.html', {'kichwa': 'Magogo ya makosa', 'Pagetitle': 'Magogo ya makosa', 'Vidokezo': 'Hizi ndizo kumbukumbu za makosa ya hivi karibuni.', 'Trace': magogo, 'kamili': kweli}) @login_required @user_pass_test (is_superuser_or_vendor) def logs_api (ombi): Magogo = onyesha_code (Get_logs ()) Rudisha httpresponse (magogo) @login_required def handler404 (ombi, isipokuwa): Ikiwa sio ombi.path.endswith ('/'): rudisha kuelekeza (ombi.path + '/') kurudi kutoa (ombi, 'makosa/kosa.html', {'kichwa': 'kosa 404', 'pagetitle': 'kosa 404', 'maelezo': 'Ukurasa huu haukupatikana kwenye seva. Inaweza kuwa imehamia au kufutwa.', 'IS_404': True}) def handler500 (ombi): Chapisha (Get_Current_Exception ()) mtumiaji = hakuna Ikiwa HasAttr (ombi, 'mtumiaji') na ombi.user na ombi.user.is_authentied: mtumiaji = ombi.user jaribu: Kosa.objects.create (mtumiaji = mtumiaji, stack_trace = Get_Current_Exception (), maelezo = 'Imefungwa na 500 Handler.') Isipokuwa: kupita Rudisha kutoa (ombi, 'makosa/kosa.html', {'kichwa': 'kosa 500', 'pagetitle': 'kosa 500', 'maelezo': 'Kuna shida na seva, au kwa ombi linalokuja kutoka kwako. Asante kwa uelewa wako wakati tunapanga mambo.' Def Handler403 (ombi, isipokuwa): Rudisha utoaji (ombi, 'makosa/kosa.html', {'kichwa': 'kosa 403', 'pagetitle': 'kosa 403', 'maelezo': def handler400 (ombi, isipokuwa): kurudi kutoa (ombi, 'makosa/kosa.html', {'kichwa': 'kosa 400', 'pagetitle': 'kosa 400', 'maelezo': 'Hii ilikuwa ombi mbaya.'})

Unda maoni yako hapa.

Ifuatayo, wacha tufafanue middleware kushughulikia makosa haya. Tutafanya hivyo kwa kuongeza kwanza kwa MiddAre_class katika Mipangilio.py, na jina la Middleware yetu.

Middware_classes = [ #... Middleware ya zamani 'Makosa.middleware.ExceptionBoseMiddDaware, ]

... Middleware ya zamani

Ifuatayo, wacha tuongeze middleware.
nano users/models.py
Kutoka kwa kuingiza kuagiza ndani kuagiza traceback kutoka django.utils.Deprecation kuagiza MiddleMaremixin _error = mitaa () Darasa la ExcerBoseMiddDaware (MiddleWareMixin): Def process_exception (ubinafsi, ombi, isipokuwa): _error.value = traceback.format_exc () def kupata_current_exception (): jaribu: kurudi _error.value Isipokuwa AttributeError: kurudi hakuna def set_current_exception (isipokuwa): jaribu: _error.value = ubaguzi Isipokuwa AttributeError: Chapisha ('sifa ya kuweka makosa.')
# Tunaongeza kazi kupata ubaguzi wa sasa kwa kutumia vifaa vya ndani, ambavyo hutusaidia kufuata makosa yoyote katika nambari yetu. Kwa upande wa templeti, tunahitaji moja tu, kwa sababu tunafafanua kwa nguvu kichwa katika maoni. Kiolezo kinahitaji tu kutoa kichwa na "kuwaeleza", makosa yetu ya kufuatilia kutoka kwa muktadha.
Makosa ya Nano/templeti/makosa/kosa.html

{ % hupanua 'msingi.html' %} { % block yaliyomo %} {{PageTitle}} {{trace}} { % endblock %}

Hii ni template yetu rahisi bado, lakini ndivyo ilivyo rahisi kuona makosa katika mradi wetu. Ifuatayo, wacha tulemee Debug katika Mipangilio.
# Nano App/Mipangilio.py
            TimestampSigner().unsign(key, max_age=60 * 60 * 24 * 30) # Pata mstari huu ambapo imewekwa kweli, na ubadilishe kuwa ya uwongo
Debug = Uongo

Nenda mbele na chelezo programu sasa. Tuko tayari kupeleka kwa seva ya mbali ya Linux, na endelea kuongeza huduma kutoka hapo.

Backup ya Sudo

Kabla ya kutuma nambari hii kwa seva, tunapaswa kuzingatia kuwa kunaweza kuwa na maswala kadhaa na nambari. Kulingana na kesi hiyo, tovuti ambazo zinakubali habari zilizotumwa kwao zitakuwa na maswala na barua taka zilizowekwa na ugumu wa kuondoa barua taka. Hii haifai kutokea mara moja, lakini ikiwa inafanyika, baadaye tutachunguza jinsi ya kueneza spam moja kwa moja kwenye wavuti na kuifanya iwe ngumu kwa roboti kupata tovuti, pamoja na jinsi ya kuzima akaunti za watumiaji, na uhakikishe kitambulisho cha mtumiaji na skana ya kitambulisho chao au skanning ya biometriska, kama alama ya vidole au utambuzi wa usoni.

Kuangalia mfano wa uthibitishaji wa sababu nyingi tulizochunguza, katika uzalishaji, mambo yanaweza kuwa tofauti. Angalia jinsi tunavyopunguza kiwango cha kuingia, na ishara za kumalizika. Ikiwa roboti zinapata tovuti, uthibitishaji wa sababu mbili unaweza kuwa ngumu zaidi kwani zinaweza kuingia kwenye nambari wakati huo huo mtumiaji ni. Ili kupambana na hii, wacha tutumie mfano katika mifano ya watumiaji, tukitangaza jinsi tunavyoingiliana na wavuti wakati tunathibitisha kutumia uthibitishaji wa sababu nyingi na nambari ya simu. Pia tutaongeza chaguo la kudhibitisha na barua pepe. Anza kwa kuhariri mifano ya watumiaji na Nano.
nano users/views.py
Watumiaji wa Nano/Models.py

Hii ndio mfano ambao tunaongeza unapaswa kuonekana. Hatuitaji njia zozote, vigezo tu vya kuhifadhi kitambulisho, mtumiaji, njia ya muda, kumalizika, urefu na majaribio dhidi ya uthibitisho wowote wa sababu nyingi (nambari kama 123456 iliyotumwa kwa simu au barua pepe).

# Ishara ya kimsingi iliyotumika kuingia kwenye wavuti darasa MFATOKEN (modeli.model): mtumiaji = models.ForeignKey (mtumiaji, on_delete = models.cascade, uhusiano_name = 'mfa_tokens') timestamp = models.DateTimeField (default = timezone.now) Inamalizika = Models.DateTimeField (chaguo -msingi = Timezone.Now) Ishara = Models.Charfield (chaguo -msingi = '', max_length = 100) urefu = models.IntegerField (chaguo -msingi = 6) majaribio = models.IntegerField (chaguo -msingi = 0) uid = models.charfield (chaguo -msingi = uuid.uuid4, max_length = 100)
from .email import send_verification_email # Ishara ya kimsingi iliyotumika kuingia kwenye wavuti
Wacha pia tuongeze fursa kwa mtumiaji wetu, na tutaiweka kwa mikono kwa sasa, kabla ya kuhamia kwa kuwaorodhesha watumiaji wenye upendeleo moja kwa moja. Katika mifano ya mtumiaji, ongeza mstari huu kwenye wasifu:

muuzaji = models.booleanfield (chaguo -msingi = uongo)

Kama ilivyo kwa mabadiliko yoyote kwenye hifadhidata, tunahitaji kufanya uhamishaji na kuhamia hifadhidata wakati wowote tunabadilisha faili ya modeli.py katika Django. Kumbuka, kufanya hivyo tunatumia chanzo kwanza (ikiwa haijatumika tayari tangu terminal ilikuwa wazi) na kisha python kusimamia.py kufanya uhamiaji na kuhamia.

CD-sarectory-wewe-jina # (ikiwa inahitajika) Chanzo Venv/bin/actishate Python Management.py Makemigrations && Python Usimamizi.py kuhamia

(ikiwa inahitajika)
        # Kwa sasa, unaweza kuorodhesha akaunti zozote ambazo umeunda kama wachuuzi kwa kutumia ganda.
    # Python kusimamia.py ganda
kutoka kwa watumiaji.Models Profaili ya kuagiza
p = wasifu.objects.get (mtumiaji__UserName = 'charlotte')
P.VENDOR = KWELI
P.Save ()
Utgång()
# Sasa, wacha tutoe maoni yetu ya uthibitisho wa sababu nyingi kutumia ishara hii. Kwanza, tunahitaji kurekebisha huduma zetu za msaidizi wa MFA. Kutumia nano,
Watumiaji wa Nano/MFA.py

kutoka django.utils kuagiza saa ya saa Ingiza nasibu kuagiza wakati wa tarehe Kutoka kwa mipangilio ya kuagiza ya Django.conf kutoka kwa feed.Middleware kuagiza kupata_current_request Kutoka kwa Django.contrib Ujumbe wa kuagiza kutoka .Email kuagiza send_html_email kuagiza traceback kutoka .Models kuagiza mfatoken Account_sid = Mipangilio.twilio_account_sid AUTH_TOKEN = mipangilio.twilio_auth_token Source_Phone = Mipangilio.Phone_Number def send_text (lengo_phone, maandishi): Kutoka kwa Twilio.Rest Mteja wa kuagiza jaribu: Mteja = Mteja (Akaunti_sid, Author_Token) Ikiwa len (lengo_phone)> = 11: ujumbe = mteja.messages.create ( to = lengo_phone, Kutoka_ = chanzo_phone, mwili = maandishi + 'maandishi kuacha kughairi.') isipokuwa: ujumbe.warning (Get_Current_Request (), 'kulikuwa na kosa kutuma ujumbe.') Chapisha (traceback.format_exc ()) def kupata_num_length (nambari, urefu): n = '' Kwa x katika anuwai (urefu): n = n + str (num) Rudisha int (n) def send_verification_text (mtumiaji, ishara): urefu = mtumiaji.profile.verification_code_length nambari = nasibu.randint (Get_num_length (1, urefu), Get_num_length (9, urefu)); token.token = nambari token.expires = timezone.now () + dateTime.timedelta (dakika = mipangilio.auth_valid_minutes) Ishara.save () send_user_text (mtumiaji, "nambari yako ya uthibitisho wa {} ni {}". (Mipangilio.site_name, str (nambari))) def send_verification_email (mtumiaji, ishara): urefu = mtumiaji.profile.verification_code_length nambari = nasibu.randint (Get_num_length (1, urefu), Get_num_length (9, urefu)); token.token = nambari token.expires = timezone.now () + dateTime.timedelta (dakika = mipangilio.auth_valid_minutes) Ishara.save () send_html_email (mtumiaji, "nambari yako ya uthibitisho wa {} ni {}". (mipangilio.site_name, str (msimbo)), "mpendwa {}, nambari yako ya uthibitisho wa {} ni {}. Asante kwa kutumia nambari hii kupata akaunti yako. {} Kwa dhati, {}". str (nambari), mipangilio.site_name))) def send_user_text (mtumiaji, maandishi): send_text (mtumiaji.profile.phone_number, maandishi) def check_verification_code (mtumiaji, ishara, msimbo): Token.Attempts = Token.Attempts + 1 wasifu = mtumiaji.profile matokeo = (ishara! = hakuna na nambari! = '' na token.token == msimbo na (token.expires> timezone.now ()) na token.attempts <= mipangilio.mfa_token_attempts) ikiwa ishara.attempts <3 na matokeo: wasifu.verification_code_length = 6 elif token.attempts> 1 na sio matokeo: wasifu.verification_code_length = wasifu.verification_code_length + 2 Ikiwa wasifu.verification_code_length> mipangilio.mfa_token_length: wasifu.verification_code_length = mipangilio.mfa_token_length Ishara.save () wasifu.save () matokeo ya kurudi

# Thibitisha mtumiaji kwa kutumia barua pepe yao au nambari ya simu DEF MFA (ombi, jina la mtumiaji, UserToken): Ishara = mfatoken.objects.filter (uid = jina la mtumiaji, inaisha__gt = timezone.now () + tareheTime.timedelta (sekunde = 30)) order_by ('-timestamp'). Ikiwa sio ishara: ishara = mfatoken.objects.create (mtumiaji = mtumiaji.objects.filter (wasifu__uuid = jina la mtumiaji) .First (), uid = jina la mtumiaji, linaisha = timezone.Now () + DateTime.timedelta (sekunde = 115) # ikiwa haijaundwa, itengeneze. mtumiaji = mtumiaji.objects.filter (id = token.user.id) .first () # Pata mtumiaji kutoka kwa ishara Ikiwa sio mtumiaji na ombi.user.is_authentited: rudisha uelekeze (reverse ('feed: nyumba') # ikiwa tayari imethibitishwa, ingia ndani Ikiwa sio mtumiaji: ongeza ruhusa Ifuatayo = ombi.get.get ('ijayo', '') Ikiwa sio mtumiaji.profile.enable_two_factor_authentication na mtumiaji.is_active na mtumiaji.profile.check_auth_token (Usertoken, ishara): # Angalia ishara ya Author AUTH_LOGIN (ombi, mtumiaji, backend = 'django.contrib.auth.backends.modelback') # Ingia kwa mtumiaji ikiwa tayari hawajaingia ndani mtumiaji.profile.mfa_expires = timezone.now () + dateTime.timeDelta (dakika = mipangilio.login_valid_minutes) # Weka kumalizika kwa uthibitisho wao wa sababu nyingi mtumiaji.profile.save () Rudisha httpResponseReDirect (ijayo ikiwa ijayo! = '' mwingine ubadilishe ('kutua: kutua')) # Melekeze mtumiaji kwenye ukurasa unaofuata Ikiwa sio mtumiaji.profile.mfa_enured: # Angalia ikiwa MFA imewezeshwa Ikiwa sio Check_verification_time (mtumiaji, ishara): # Angalia wakati Mtumiaji.profile.mfa_enured = uwongo # Futa nambari ya simu mtumiaji.profile.enable_two_factor_authentication = kweli # Wezesha MFA mtumiaji.profile.phone_number = '+1' # Lemaza nambari ya simu mtumiaji.profile.save () # Hifadhi wasifu Author_login (ombi, mtumiaji, backend = 'django.contrib.auth.backends.modelback') # Ingia mtumiaji ikiwa MFA yao haijawezeshwa ujumbe.warning (ombi, 'Tafadhali ingiza nambari halali ya simu na uhakikishe na nambari.') Rudisha uelekeze (reverse ('Watumiaji: MFA_onboarding')) Ikiwa ombi.method == 'chapisho' na sio udanganyifu_detect (ombi, kweli): # Ikiwa ombi ni ombi la posta fomu = tfaform (ombi.post) # ongeza fomu nambari = str (form.data.get ('nambari', hakuna)) # Pata nambari Ikiwa nambari na nambari! = '' na nambari! = Hakuna: # hakikisha sio tupu token_validated = mtumiaji.profile.check_auth_token (UserToken) # Angalia ishara ya mwandishi p = mtumiaji.profile is_verized = check_verification_code (mtumiaji, ishara, nambari) # Angalia nambari p.mfa_authentied = is_verized Ikiwa token_validated: # ikiwa kila kitu Ikiwa ni_erified: # iko katika mpangilio mtumiaji.profile.mfa_enured = kweli # Wezesha MFA (ikiwa haijawezeshwa tayari) mtumiaji.profile.save () AUTH_Login (ombi, mtumiaji, backend = 'django.contrib.auth.backends.modelback') # logi katika mtumiaji uso = mtumiaji.faces.filter (kikao_key = hakuna) .last () p.mfa_expires = timezone.now () + dateTime.timedelta (dakika = mipangilio.login_valid_minutes) P.Save () Ujumbe.Success (Ombi, 'Umethibitishwa. Karibu.') QS = '?' Kwa ufunguo, thamani katika ombi.get.items (): # Jenga hoja ya hoja kwa param inayofuata (ikiwa ipo) QS = QS + Key + '=' + Thamani + '&' Ikiwa ijayo! = '' na sio (Next.StartSwith ('/Akaunti/logout/') au Next.StartSwith ('/Akaunti/kuingia/') au Next.StartSwith ('/admin/logi/') au Next.Startswith ('/Akaunti/Usajili/'):): Rudisha HttpResponseReDirect (ijayo) # kuelekeza elif ijayo.startswith ('/akaunti/logout/') au ijayo.startswith ('/akaunti/kuingia/') au ijayo.startswith ('/akaunti/rejista/'): Rudisha uelekeze (reverse ('/')) ombi la elif.meta.get ('http_referer', '/').startswith('/accounts/login/'): Rudisha uelekeze (reverse ('/')) Elif sio ijayo: Rudisha uelekeze (reverse ('/')) mwingine: Rudisha httpResponseReDirect (reverse ('thibitisha: umri') + '? ijayo =' + ombi.Meta.get ('http_referer', '/')) mwingine: Ujumbe.warning (ombi, 'Nambari uliyoingiza haikutambuliwa. Tafadhali jaribu tena.') Elif sio token_validated: # ikiwa ishara ilikuwa batili Ujumbe.warning (ombi, 'Ishara ya URL imekwisha au haikutambuliwa. Tafadhali jaribu tena.') Kuingia (ombi) Rudisha uelekeze (reverse ('watumiaji: kuingia')) Ikiwa p.mfa_attempts> 3: # ikiwa kulikuwa na majaribio mengi mno ujumbe.warning (ombi, 'Wewewameingia nambari isiyo sahihi zaidi ya mara 3. Tafadhali tuma nambari mpya. ') P.Verification_code = hakuna P.Save () elif mtumiaji.profile.can_send_mfa <timezone.now (): mtumiaji.profile.mfa_attempts = 0 mtumiaji.profile.can_send_mfa = timezone.now () + tareheTime.timedelta (dakika = 2) mtumiaji.profile.save () Ikiwa fomu.data.get ('send_email', uongo): # Tuma barua pepe (au maandishi) send_mfa_verification_email (mtumiaji, ishara) mwingine: send_verification_text (mtumiaji, ishara) Ujumbe.Success (Omba, "Tafadhali ingiza nambari iliyotumwa kwa nambari yako ya simu au barua pepe. Nambari itaisha kwa dakika 3.") elif mtumiaji.profile.can_send_mfa <timezone.now () + dateTime.timedelta (sekunde = 115): ujumbe.warning (ombi, 'unatuma nambari nyingi za uthibitisho wa sababu mbili. Subiri dakika chache kabla ya kutuma nambari nyingine.') fomu = tfaform () kujificha_logo = hakuna Ikiwa mtumiaji.profile.hide_logo: kujificha_logo = kweli Ikiwa ombi.user.is_authentied: rudisha uelekeze (reverse ('/')) # Toa fomu (kwa maombi ya kupata) Rudisha utoaji (ombi, 'watumiaji/mfa.html', {'kichwa': 'ingiza nambari', 'fomu': fomu, 'xsmall': kweli, 'mtumiaji': mtumiaji, 'ficha_logo': ficha_logo, 'accl_logout': mtumiaji.profile.shake_to_logout, 'preloatt': uongo ': uongo,' uongo, 'uongo': uongo ': uongo,
nano users/views.py
Thibitisha mtumiaji kwa kutumia barua pepe yao au nambari ya simu
# Chuja ishara kwa thamani iliyopitishwa kwenye URL (UUID)
# Ikiwa kikao hiki hakijaundwa, uunda
Pata mtumiaji kutoka kwa ishara

Ikiwa tayari imethibitishwa, ingia

Kataa ikiwa hakuna mtumiaji aliyepatikana
# Angalia ishara ya mwandishi
            send_verification_email(user) # Ingia kwa mtumiaji ikiwa hawajaingia tayari
Weka kumalizika kwa uthibitisho wao wa sababu nyingi

Melekeze mtumiaji kwenye ukurasa unaofuata

Angalia ikiwa MFA imewezeshwa
# Angalia wakati
Futa nambari ya simu

Wezesha MFA

Lemaza nambari ya simu
nano users/templates/users/resend_activation.html
Hifadhi wasifu

Ingia mtumiaji ikiwa MFA yao haijawezeshwa

Ikiwa ombi ni ombi la posta
Panga fomu

Pata nambari

Hakikisha sio tupu
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)
Angalia ishara ya mwandishi

Angalia nambari

Ikiwa kila kitu
Ni kwa utaratibu

Wezesha MFA (ikiwa haijawezeshwa tayari)

Ingia mtumiaji

Jenga QueryString kwa param inayofuata (ikiwa ipo)

Kuelekeza

Ikiwa ishara ilikuwa batili

Ikiwa kulikuwa na majaribio mengi mno
# Tuma barua pepe (au maandishi)
Toa fomu (kwa maombi ya kupata)

Wakati tunaongeza katika nambari hii, hakikisha kuagiza kazi hiyo kutuma barua pepe. Juu ya faili, maoni ya mtumiaji (na uagizaji mwingine), ongeza

kutoka .MFA kuagiza send_verification_email kama SEND_MFA_VERIFICATION_EMAIL
Sasa, tunahitaji kuandika kazi hiyo kabla ya hii yoyote kufanya kazi. Inapaswa kupanua kazi yetu ya kutuma barua pepe, na tu tuma barua pepe kwa mtumiaji na nambari ya uthibitishaji.

Watumiaji wa Nano/MFA.py

def send_verification_email (mtumiaji, ishara): urefu = mtumiaji.profile.verification_code_length nambari = nasibu.randint (Get_num_length (1, urefu), Get_num_length (9, urefu)); token.token = nambari token.expires = timezone.now () + dateTime.timedelta (dakika = mipangilio.auth_valid_minutes) Ishara.save () send_html_email (mtumiaji, "nambari yako ya uthibitisho wa {} ni {}". (mipangilio.site_name, str (msimbo)), "mpendwa {}, nambari yako ya uthibitisho wa {} ni {}. Asante kwa kutumia nambari hii kupata akaunti yako. {} Kwa dhati, {}". str (nambari), mipangilio.site_name)))
Kwa hivyo hii yote inafanya kazi nzuri, sasa tunayo mfumo wa uthibitishaji wa sababu nyingi ambao unategemea nambari ya simu au barua pepe kuingia. Lakini pia tunahitaji njia ya kuondoa, au angalau kuficha watumiaji ambao hawashirikiana na masharti yetu. Hizi zinaweza kuwa spammers, roboti au mtu yeyote ambaye haimaanishi vizuri kwa kazi yetu. Angalia maoni ninayo ya kuangalia watumiaji kwenye wavuti yangu:

# uagizaji kutoka django.contrib.auth.decorators kuagiza login_required kutoka django.contrib.auth.decorators kuagiza mtumiaji_pass_test Kutoka .Kuingiza. @login_required @user_pass_test (is_superuser_or_vendor) Watumiaji wa DEF (ombi): # Pata orodha ya watumiaji NEW_TODAY = mtumiaji.objects.filter (is_active = kweli, tarehe_joined__gte = timezone.now () - TareheTime.timedelta (masaa = 24). Hesabu () New_this_month = mtumiaji.objects.filter (is_active = kweli, tarehe_joined__gte = timezone.now () - dateTime.timedelta (masaa = 24*30). hesabu () Wasajili = mtumiaji.objects.filter (is_active = kweli, wasifu__subscribed = kweli) .count () kurudi kutoa (ombi, 'watumiaji/watumiaji.html', { # kurudi watumiaji kwenye template 'Kichwa': 'Akaunti zote', 'Watumiaji': mtumiaji.objects.all (), 'New_Today': New_Today, 'New_this_month': New_this_month, 'Wasajili': Wasajili })

Uagizaji
Tutahitaji kuunda mtihani huu

Pata orodha ya watumiaji

Rudisha watumiaji kwenye template
Kumbuka kuwa nambari hii hutumia mtihani, tutahitaji kutangaza mtihani huu katika faili ya majaribio.py na kuiingiza. Kuhariri watumiaji/majaribio.py, wacha tuunda mtihani.

DEF IS_SUPERUSER_OR_VENDOR (mtumiaji): rudisha mtumiaji.profile.vendor au mtumiaji.is_superuser

Hii ni kwa kushirikiana na watumiaji/watumiaji.html template, ambayo inaonekana kitu kama hiki:
{ % hupanua 'msingi.html' %} { % mzigo programu_filters %} { % block yaliyomo %} Wageni wote waliosajiliwa [ { % kwa mtumiaji katika watumiaji %} { % ni pamoja na 'watumiaji/_user.html' %} { % Endfor %} { % endblock %}

Mtumiaji.html. Wakati wa kutumia template ambayo ina subtemplate na sio kutumia kupanuka, ni wazo nzuri kuongeza underscore (

Kumbuka kuwa hii ni mengi ya Jinja, unaweza kuwa hauna tofauti hizi zote zilizoelezewa. Lakini hii ndio nambari yangu inaonekana.
    # { % mzigo programu_filters %}


    
      @{{mtumiaji.username}} - {{mtumiaji.profile.name}} ({{mtumiaji.profile.preferred_name}}))
      Mara ya mwisho kuonekana {{mtumiaji.profile.last_seen | tarehe: "f d, y"}}
      Alijiunga na {{mtumiaji.profile.date_joined | tarehe: "f d, y"}} {{mtumiaji.profile.date_joined | wakati: "h: i"}}}
      {{mtumiaji.email}}
      { % ikiwa mtumiaji.profile.phone_number %} {{mtumiaji.profile.phone_number}} { % endif %}
      { % ikiwa mtumiaji.verifications.last %}
      '
       {{mtumiaji.verifications.last.document_number}}
       {{user.verifications.last.birthdate}}
       Kitambulisho cha mbele
       Id nyuma
      { % endif %}
      #{{mtumiaji.id}}
      { % ikiwa mtumiaji.profile.subscribed %} Imesajiliwa { % nyingine %} Haijasajili { % endif %}
    
    { %ikiwa sio mtumiaji.is_superuser %}
    { % ni pamoja na 'watumiaji/toggle_active.html' %}
    { % endif %}
    { % AutoEscape Off %}    
    {{mtumiaji.bio}}
    { % endautoescape %}
    
    { % ikiwa mtumiaji.profile.identity_verized %} mtumiaji aliyethibitishwa. { % nyingine %} mtumiaji ambaye hajathibitishwa.
{{mtumiaji.id}} </small>

Tunahitaji pia subtemplate nyingine, toggle_active.html. Kiolezo hiki kinapaswa kuwa fomu ambayo inaruhusu sisi kugeuza ikiwa mtumiaji anafanya kazi.

{ % ikiwa mtumiaji.is_active %} { % nyingine %} { % endif %}

Tutahitaji pia kuongeza mtazamo wa kubadilisha shughuli za watumiaji, na mifumo sahihi ya URL. Wakati tuko ndani yake, wacha tuongeze mtazamo wa kufuta mtumiaji ikiwa tutahitaji hiyo.

kutoka django.views.decorators.csrf kuagiza csrf_exempt @csrf_exempt @login_required @user_pass_test (is_superuser_or_vendor) def toggle_user_active (ombi, pk): mtumiaji = mtumiaji.objects.get (id = pk) Ikiwa ombi.method == 'chapisho': mtumiaji.is_active = sio mtumiaji.is_active mtumiaji.save () rudisha httpresponse ('' ikiwa mtumiaji.is_active mwingine '') # Uagizaji kutoka django.contrib.auth.mixins kuagiza loginRequiredMixin, mtumiajiSassSestMixin kutoka django.views.generic kuagiza Deleteview UserDeleteview ya darasa (LoginRequiredMixin, mtumiajiPassEstMixin, DeleTeview): mfano = mtumiaji mafanikio_url = '/' # kuelekeza kwenye URL ya mafanikio def kupata_context_data (ubinafsi, ** Kwargs): muktadha = super (). Get_context_data (** Kwargs) Kurudisha muktadha def test_func (ubinafsi): # mtihani ikiwa mtumiaji ni superser na ana ruhusa ya kufuta mtumiaji = self.get_object () Ikiwa self.request.user! = Mtumiaji na self.request.user.is_superuser: Rudi kweli kurudi uwongo

Uagizaji

Kuelekeza kwenye URL ya mafanikio
# Jaribu ikiwa mtumiaji ni superser na ana ruhusa ya kufuta
    # Wakati hii ni ya vitendo wakati inahitajika, kufuta mtumiaji haipaswi kuwa muhimu wakati mwingi, tunaweza tu kubadilisha mwonekano wa watumiaji wanaotembelea tovuti ikiwa tunahitaji kuwafukuza.
    # Mifumo ya URL ambayo tumeongeza inaonekana kama hii. Na nano, hariri watumiaji/urls.py na ongeza mistari hii:
            TimestampSigner().unsign(key, max_age=60 * settings.AUTH_VALID_MINUTES) # watumiaji wa Nano/urls.py
Mistari inapaswa kwenda katika orodha ya njia katika maoni ya mtumiaji, kabla ya kumalizika "]" lakini baada ya mwanzo "[".

#… njia ('mtumiaji // kufuta/', mtumiajiDeleteView.as_view (template_name = 'blog/sese_confirm_delete.html'), jina = 'futa-mtumiaji'), njia ('mtumiaji // hai/', maoni.toggle_user_active, jina = 'kugeuza-mtumiaji-kazi'), #…

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

Sasa, hakikisha kuunga mkono tovuti ili uweze kuipakua kwenye seva ya wavuti ambayo tutaendelea kufanya kazi. Kutoka kwa mstari wa amri,

Backup ya Sudo

Sasa tovuti yetu imehifadhiwa.

Kwa hivyo sasa tunayo huduma chache muhimu. Lakini vipi kuhusu picha kubwa hapa? Nambari hii bado haipatikani kutoka kwa mtandao, bado hatuna seva ya barua, na tunahitaji kupanua programu yetu ili kujumuisha mchakato kamili wa ukaguzi na pia mpangilio laini kutusaidia kuchunguza tovuti, pamoja na itifaki salama za kudhibitisha watumiaji wenye haki.
# Tutapata haya yote. Jambo muhimu zaidi kwa sasa itakuwa tu kupata nambari hii mkondoni, ambayo tunaweza kufanya na mistari michache tu ya bash kwenye seva ya Ubuntu. Utahitaji kukodisha seva kwa hili, isipokuwa unayo seva nyumbani na usajili wa mtandao wa biashara ambao hukuruhusu kufungua bandari. Binafsi ninaendesha wavuti yangu kwenye HP Z440 ambayo imewekwa katika nyumba yangu, lakini kawaida ni rahisi sana kwa mahitaji ya msingi ya kukodisha seva ya kibinafsi (VPS).
        if user and user.profile.can_login < timezone.now(): # Kumbuka kwamba nambari tunayoendesha sasa ni nyembamba, itahitaji kutunzwa na kuboreshwa kabla ya kuwa tayari kutumia kile tunachohitaji kujenga bidhaa. Hakikisha kuwa mwangalifu unachofanya na mtandao, hakikisha ikiwa unapeleka tovuti hii hadharani kwenye wavuti kwenye seva ya Linux, una mpango wa kuzuia mwingiliano usiohitajika na wavuti yako. Hii inaweza kuwa shida mwanzoni, lakini tutaangalia suluhisho anuwai ya kupambana na hii, pamoja na kujifunza mashine, akili bandia na maono ya kompyuta. Wakati inakuwa shida, angalia zaidi katika maandishi haya kwa suluhisho.
            # Kwa upande wa kukodisha VPS, kuna maeneo mengi unaweza kwenda. Google Cloud ina seva za VPS, Ionos, Kamatera, Amazon AWS, na watoa huduma zaidi hutoa suluhisho za seva ya wingu ambayo itafaa mahitaji yetu.
                return redirect(user.profile.create_auth_url()) # Utahitaji kubonyeza fomu zao na uchague mpango wa kuanza. Unaweza kwenda na mpango wa kimsingi na mtoaji yeyote, lakini hakikisha mtoaji hukuruhusu kufungua bandari za seva za Barua pepe kutuma barua pepe (hii inapaswa kuwa bandari 587 na bandari 25), watoa huduma wengine huzuia bandari hizi. Kufikia sasa nimekuwa na uzoefu bora na Ionos na Kamatera, wote wawili wataniruhusu kutuma barua pepe isiyo na kikomo na bei zao ni rahisi.
            else: # Utaunganisha kwa seva yako mpya juu ya itifaki inayoitwa SSH au Salama Shell, ambayo hukuruhusu unganisho kwa mbali na seva haswa kama kompyuta yako ya kibinafsi, kutoka kwa kompyuta yako ya kibinafsi. Unapoweka seva, mtoaji mwenyeji anaweza kukuuliza uongeze kitufe cha SSH, au watakupa jina la mtumiaji na nywila. Ufunguo wa SSH ni jinsi utakavyoingia kwenye seva kutoka kwa mstari wa amri kuhariri nambari. Tumia chaguzi za chini za SSH-Keygen kutoa kitufe cha SSH.
        else: # SSH-Keygen
            user = User.objects.filter(username=username).first() # Hifadhi faili na uibadilishe ikiwa unahitaji, ni vizuri kuzungusha funguo zako za SSH ikiwa haujawahi. Sasa, unaweza kutumia amri ifuatayo kuona ufunguo wako wa SSH. Utataka kuiga kwa seva yako ya mbali ili uweze kuitumia ili kudhibitisha.
                profile.can_login = timezone.now() + datetime.timedelta(seconds=15) # paka ~/.ssh/id_rsa.pub
Ikiwa haukuweza kuona kitufe cha SSH wakati wa kuandika amri hiyo (safu ndefu ya nambari na herufi zinazoanza na "SSH-RSA AAA"), jaribu kutoa kitufe cha RSA (ziko salama zaidi, kwa hivyo ninashauri kuzitumia.) Nambari ifuatayo itatoa kitufe cha 4096 BIT RSA SSH.

SSH -Keygen -t RSA -B 4096

Unda VPS inayoendesha Ubuntu, hata hivyo unapanga kufanya hivyo. Mara tu umeunda VPS kwa kubonyeza fomu kwenye wavuti ya watoa huduma (kamatera.com, ionos.com au sawa), utataka kuingia. Ili kufanya hivyo, tumia amri ya SSH na anwani yako ya IP (anwani inayoonekana kama xx.xx.xx.xx). Pia utahitaji kuwa nyeti kwa jina la mtumiaji la msingi kwenye seva tuliyounda, kwa mfano, Ubuntu.

ssh ubuntu@xx.xx.xx.xx

Unaweza kuulizwa nywila, ikiwa umeulizwa nywila, ingiza ndani. Hatutatumia jina la mtumiaji la msingi, kwa hivyo wacha tuanze kwa kuunda mtumiaji mpya na kuongeza kitufe cha SSH kwenye akaunti yao.
nano users/sms.py
Wacha tuanze kwa kuongeza faili mpya ya SSHD_Config, ambayo inamwambia seva jinsi ya kutumia SSH.
# nano sshd_config
# # Hii ndio faili ya usanidi wa seva ya SSHD.  Tazama
# sshd_config (5) kwa habari zaidi.

# SSHD hii iliundwa na njia =/usr/mitaa/sbin:/usr/mitaa/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/michezo

# Mkakati unaotumika kwa chaguzi katika sshd_config chaguo -iliyosafirishwa na
# OpenSsh ni kutaja chaguzi na thamani yao ya msingi wapi
# Inawezekana, lakini waache wakatoa maoni.  Chaguzi ambazo hazijakamilika zinazidi
# Thamani ya chaguo -msingi.

#Port 22
#Addressfamily yoyote
#Listenaddress 0.0.0.0
#Listenaddress ::

#Hostkey/nk/ssh/ssh_host_rsa_key
#Hostkey/nk/ssh/ssh_host_ecdsa_key
#Hostkey/nk/ssh/ssh_host_ed25519_key

# Ciphers na keying
#Rekeylimit default hakuna

# Kuingia
#SyslogFacility Author
#Loglevel Maelezo

# Uthibitishaji:

#LogingraceTime 2m
#PermitrootLogin kukataza neno
#Strictmode ndio
#MaxauthTries 6
#Maxsessions 10

PubKeyAuthentication Ndio

# Tarajia .SSH/Airtozed_Keys2 kutokupuuzwa na chaguo -msingi katika siku zijazo.
AirthodKeysFile .SSH/Airthered_Keys .SSH/Airtozed_Keys2

#AuthorizedPrincipalsFile Hakuna

#AuthorizedKeysCommand hakuna
#AuthorizedKeysCommanduser Hakuna

# Kwa hili kufanya kazi pia utahitaji funguo za mwenyeji katika/nk/ssh/ssh_now_hosts
#HostBasedAuthentication no
# Badilisha kuwa ndio ikiwa hauamini ~/.ssh/kujulikana_
# HostbasedAuthentication
#Ignoreuser haijulikani hapana
# Usisome faili za mtumiaji ~/.rhosts na ~/.
#IgnorerHosts Ndio

# Kulemaza nywila za maandishi wazi, badilisha kuwa hapana hapa!
Ushauri wa nenosiri hapana
#PermitempTyPasswords NO

# Badilisha kuwa NDIYO ili kuwezesha nywila za majibu ya changamoto (Jihadharini na maswala na
# Moduli na nyuzi za PAM)
KBDinteractiveAuthentication no

Chaguzi za # Kerberos
#Kerberosauthentication no
#Kerberosorlocalpasswd ndio
#KERBEROSTICETCLEANUP YES
#Kerberosgetafstoken no

Chaguzi za # gssapi
#Gssapiauthentication no
#Gssapicleanupcredentials ndio
#GssapistrictAcceptorCheck ndio
#Gssapikeyexchange hapana

# Weka hii kwa 'ndio' ili kuwezesha uthibitishaji wa PAM, usindikaji wa akaunti,
# na usindikaji wa kikao. Ikiwa hii imewezeshwa, uthibitisho wa PAM utafanya
# kuruhusiwa kupitia KBDinteractiveAuthentication na
# Nywila.  Kulingana na usanidi wako wa PAM,
Uthibitishaji wa # PAM kupitia KBDinteractiveAuthentication inaweza kupita
# Mpangilio wa "vibalirootlogin bila neno-password".
# Ikiwa unataka tu akaunti ya PAM na ukaguzi wa kikao kukimbia bila
# Uthibitishaji wa PAM, kisha uwezeshe hii lakini weka usambazaji wa nywila
# na KBDinteractiveAuthentication kwa 'hapana'.
USEPAM NDIYO

#AllowagentForward ndio
#Allowtcpproward ndio
#Gatewayports hapana
X11Forwarding Ndio
#X11displayOffset 10
#X11uselocalhost ndio
#Permitty Ndio
PrintMotd hapana
#Printlastlog ndio
#Tcpkeepalive ndio
#PETMITUSERENVERNEMP HAPANA
#Matokeo ya kuchelewesha
#ClientaliveInterval 0
#ClientaliveCountMax 3
#USEDNS HAPANA
#Pidfile /run/sshd.pid
#MaxStartups 10: 30: 100
#Permittunnel hapana
#Chrootdirectory hakuna
#VersionAddendum hakuna

# Hakuna njia ya mabango chaguo -msingi
Bendera /nk /bendera

# Ruhusu mteja kupitisha anuwai za mazingira
Kukubalika lang lc_*

# Kuongeza chaguo -msingi ya hakuna mfumo mdogo
Subsystem SFTP/usr/lib/OpenSSH/sftp-seva

# Mfano wa mipangilio inayozidi kwa msingi wa mtumiaji
#Match mtumiaji anoncvs
# X11Forward hapana
# RuhusuTcpForwarding hapana
# Vibali hapana
# ForceCommand CVS Server
Vibaliootlogin hapana
# Hii ndio faili ya usanidi wa seva ya SSHD.  Tazama
# sshd_config (5) kwa habari zaidi.
# SSHD hii iliundwa na njia =/usr/mitaa/sbin:/usr/mitaa/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/michezo
# Mkakati unaotumika kwa chaguzi katika sshd_config chaguo -msingi iliyosafirishwa na
# OpenSsh ni kutaja chaguzi na thamani yao ya msingi wapi
inawezekana, lakini waache wakatoa maoni. Chaguzi ambazo hazijakamilika zinazidi

Thamani ya chaguo -msingi.

Bandari 22
# Anuani yoyote
AUTH_VALID_MINUTES = 3 # ResishAddress 0.0.0.0
MsikilizajiDdress ::

Hostkey/nk/ssh/ssh_host_rsa_key

Hostkey/nk/ssh/ssh_host_ecdsa_key
# HostKey/nk/ssh/ssh_host_ed25519_key
# Ciphers na keying
# Rekeylimit Default Hakuna
Kuingia

Syslogfacility Author

Maelezo ya Loglevel
# Uthibitishaji:
LogingraceTime 2m

Vibali vya kukataza-password

StrictMode ndio
nano users/templates/users/mfa.html
Maxauthtries 6

Maxsessions 10

Kutarajia .ssh/airtozed_keys2 kutokupuuzwa na default katika siku zijazo.
AitredPrincipalsFile Hakuna

AitredKeysCommand hakuna

AitredKeysCommanduser Hakuna
nano users/templates/users/mfa_onboarding.html
Ili hii ifanye kazi pia utahitaji funguo za mwenyeji katika/nk/ssh/ssh_now_hosts

HostbasedAuthentication no

Badilisha kuwa ndio ikiwa hauamini ~/.ssh/kujulikana_hosts kwa
HostbasedAuthentication

Kupuuza NotHostHosts no

Usisome faili za mtumiaji ~/.rhosts na ~/.

Kupuuza ndio

Ili kulemaza nywila za maandishi wazi, badilisha kuwa hapa!

Kibali chaPasswords hapana

Badilisha kuwa NDIYO ili kuwezesha nywila za majibu ya changamoto (Jihadharini na maswala na
# Baadhi ya moduli za PAM na nyuzi)
Chaguzi za Kerberos

Kerberosauthentication no

Kerberosorlocalpasswd Ndio
# KerberosticketCleanup Ndio
Kerberosgetafstoken no

Chaguzi za GSSAPI

Gssapiauthentication hapana
nano users/templates/users/profile.html
GSSAPICLeanupcredentials Ndio
GssapistrictAcceptorCheck ndio

Gssapikeyexchange hapana

Weka hii kwa 'ndio' ili kuwezesha uthibitishaji wa PAM, usindikaji wa akaunti,

na usindikaji wa kikao. Ikiwa hii imewezeshwa, uthibitisho wa PAM utafanya

kuruhusiwa kupitia KBDinteractiveAuthentication na
# UCHAMBUZI.  Kulingana na usanidi wako wa PAM,
# Uthibitishaji wa PAM kupitia KBDinteractiveAuthentication inaweza kupita
Mpangilio wa "vibalirootlogin bila neno-password".

Ikiwa unataka tu akaunti ya PAM na ukaguzi wa kikao kukimbia bila

Uthibitishaji wa PAM, kisha uwezeshe hii lakini weka uboreshaji wa nywila
backup
na KBDinteractiveAuthentication kwa 'hapana'.

Ruhusu AgentForwarding Ndio

RuhusuTcpForwarding Ndio
python manage.py runserver localhost:8000
Gatewayports hapana

X11DisplayOffset 10

X11USELOCALHOST YES

Vibali ndio

PrintLastLog Ndio

Tcpkeepalive ndio

Vibali vya mazingira hapana

Compression kucheleweshwa

MtejaInterval 0

SectiveCountMax 3

Kutumiwa hapana
python manage.py startapp errors
Pidfile /run/sshd.pid

MaxStartups 10: 30: 100

Vibali hapana
handler404 = 'errors.views.handler404'
handler500 = 'errors.views.handler500'
handler403 = 'errors.views.handler403'
Chrootdirectory hakuna

Toleoddendum hakuna

Hakuna njia chaguo -msingi ya mabango
# Ruhusu mteja kupitisha anuwai za mazingira
Kuongeza chaguo -msingi ya hakuna mfumo mdogo

Mfano wa mipangilio inayozidi kwa msingi wa mtumiaji

Mechi ya Mtumiaji Anoncvs
    # X11Forwarding hapana
RuhusuTcpForwarding hapana

Vibali hapana

ForceCommand CVS Server
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.')
Kumbuka, Ctrl+X na Y kuokoa faili. Ifuatayo, wacha tuandike hati ya msingi inayoitwa Anzisha (yote kwenye saraka ya nyumbani ya mtumiaji wetu).

Nano Anzisha

Na kitufe chako cha SSH ulichopata kutumia CAT. (.ssh/id_rsa.pub)
nano errors/templates/errors/error.html
#!/bin/bash Sudo apt kufunga -y nano git OpenSsh -seva sudo cp sshd_config/nk/ssh/sshd_config Huduma ya Sudo SSH kuanza tena Huduma ya Sudo SSHD kuanza tena echo "/root/.ssh/id_rsa" | sudo Su mizizi -c "ssh -keygen -t rsa -n ''" echo "Mzizi wa SSH muhimu:" Sudo Su mizizi -c "paka /root/.ssh/id_rsa.pub" Sudo AddUser-Timu ya kustarehe-ya-Pass -Gos "" Timu ya sudo passwd -d Timu ya Sudo Usermod -ag Sudo echo "/home/team/.ssh/id_rsa" | Timu ya SU "SSH -Keygen -t RSA -n ''" paka /home/team/.ssh/id_rsa.pub >> /home/team/.ssh/authorized_keys echo '' >> /home/team/.ssh/authorized_keys Echo "Timu ya SSH Ufunguo:" paka /home/team/.ssh/id_rsa.pub
!/bin/bash

Ili kukutembea kupitia faili hii, wacha tuanze mstari kwa mstari. Mstari wa kwanza unamwambia mkusanyaji kwamba hii ni maandishi ya bash. Halafu tunasanikisha utegemezi, kunakili SSHD_Config kwenye saraka sahihi, kuanza tena SSH, kutoa funguo za SSH kwa mzizi, na kuongeza 'timu' ya mtumiaji (unaweza kuchagua jina unalopenda kwa hii, tumia amri ya kuongeza na jina lao na nywila iliyolemazwa kwa sasa). Tunaongeza pia timu kwenye Kikundi cha Sudo, kutoa ufunguo wao wa SSH, kuongeza ufunguo wetu kwa funguo zilizoidhinishwa na zao pia, na kuchapisha ufunguo wao. Mtumiaji huyu mpya atakuwa jinsi tunavyoingia kwenye wavuti.

Katika terminal mpya, nenda mbele na ufungue seva tena.
nano app/settings.py
SSH team@xx.xx.xx.xx

Haupaswi kuhitaji nywila wakati huu, kwa kuwa una ufunguo wa SSH. Pia tumelemaza kuingia na nywila kuweka tovuti salama zaidi.

Sasa, seva hii inaanza wazi kabisa bila habari juu yake. Wacha tuanze kwa kuweka mradi wetu kutoka kwa Git ili tuweze kupakua na kuiendesha kwenye mashine ya mbali. Kwenye seva ya mbali iliyounganishwa juu ya SSH, kwanza chapisha kitufe chako cha SSH:
DEBUG = False
paka ~/.ssh/id_rsa.pub

Ifuatayo, weka ufunguo huu kwenye mipangilio ya GIT kama tulivyofanya hapo awali ili kuanzisha hazina yetu ya GIT. Tunaweza sasa kuweka mradi wetu moja kwa moja kwa seva. Hakikisha umeunga mkono mradi wa kwanza kwa hivyo iko kwenye seva ya git kupakua.

git clone git: //github.com/you/yourproject.git
sudo backup
Kamili. Sasa faili zote ziko hapa. Tunaweza kuwaona na LS

ls

Sasa, wacha tuanze kuanzisha seva. Kwanza, nakili saraka yako ya mradi kuwa jina rahisi, la kukumbukwa ambalo tutatumia kwa mradi huo.

CP -R yakoProject WhatYoucalledit

Ambapo "Whatyoucalledit" ni jina mpya la mradi wako. Ifuatayo, tutahitaji kujenga matumizi ya msingi ya kuanzisha seva. Tutaokoa matumizi haya na kuitumia katika siku zijazo. Ili kujenga matumizi haya, wacha tuunde mtumiaji wa binary kufafanua jinsi tunavyobadilisha hati. Kutumia bash, hariri/usr/bin/ascript
nano users/models.py
Sudo Nano/usr/bin/Ascript

Hakikisha kutumia sudo huko kwa hivyo unayo ruhusa ya kuhariri faili. Kwenye faili, ongeza mistari hii:

#!/bin/bash ikiwa [! -F/usr/bin/$ 1]; basi Sudo Touch/usr/bin/$ 1 echo "#!/bin/bash" >>/usr/bin/$ 1 Sudo chmod A+x/usr/bin/$ 1 Sudo Nano/usr/bin/$ 1 echo $ 1 | sudo tee -a /nk /maandishi mwingine Sudo chmod A+x/usr/bin/$ 1 Sudo Nano/usr/bin/$ 1 fi
# !/bin/bash
!/bin/bash ">>/usr/bin/$ 1

Kumbuka hati hii inachukua hoja, jina la maandishi, kama $ 1. Kwanza inakagua ikiwa faili ipo, au vinginevyo inaunda, inaongeza safu ya kwanza kutangaza maandishi ni bash, hubadilisha ruhusa zake, kuibadilisha, na inaongeza jina lake kwa /nk /maandishi ambayo huturuhusu kuhifadhi majina ya maandiko tunayounda. Ikiwa faili tayari ipo, badilisha ruhusa tu na ubadilishe. Hifadhi faili, na ijayo tutabadilisha ruhusa yake. Kadiri tunavyotumia hati hii, hatutalazimika kufanya hivyo tena.

Sudo chmod A+x/usr/bin/ascript
    vendor = models.BooleanField(default=False)
Kamili. Sasa wacha tuunda hati inayoitwa Usanidi. Kwanza, sio kukuzidi, lakini angalia maandishi yangu ya usanidi yanaonekanaje. Tutatembea kupitia kile maandishi haya yanapaswa kuonekana katika mradi wako, hautahitaji kila kitu kwenye hati yangu kuanza na.

#!/bin/bash Sekunde = 0 Python_version = 3.12 Echo "Kisakinishi cha Femmebabe kilichoanzishwa." # sudo chmod A+x script/watumiaji # ./Scripts/UserSetup # SSH-Keygen Saraka ya Mradi Dir = "/nyumbani/timu/femmebabe" Mtumiaji = "Timu" # Amri za Ingia echo "amri za ukataji miti" sudo cp logi/amri.log /var/log/commands.log sudo chmod -r a+w /var /logi Sudo Chown -r: syslog /var /logi echo $ 'alias venv = "chanzo/nyumba/timu/femmebabe/venv/bin/actisha"' | sudo tee -a /home/team/.profile echo $ 'prev_command = \' retrn_val = $?; logger -p local6.debug "$ (whoami) [$ $]: $ (historia 1 | sed" s/^[]*[0-9] \+[]*// ")" \ '' | sudo tee -a /nk /bashrc echo $ 'prev_command = \' retrn_val = $?; logger -p local6.debug "$ (whoami) [$ $]: $ (historia 1 | sed" s/^[]*[0-9] \+[]*// ")" \ '' | sudo tee -a "/home/team/.bashrc" echo $ 'prev_command = \' retrn_val = $?; logger -p local6.debug "$ (whoami) [$ $]: $ (historia 1 | sed" s/^[]*[0-9] \+[]*// ")" \ '' | sudo tee -a /root/.bashrc echo "chanzo /nk /bashrc" | sudo tee -a /home/team/.profile echo "/var/log/commands.log" | sudo tee -a /etc/logrotate.d/syslog echo "local6.* /var/log/commands.log" | sudo tee -a "/etc/rsyslog.d/bash.conf" Huduma ya Sudo Rsyslog kuanza tena # Nano Config echo "Weka Tabsize 4" >> .Nanorc Echo "Weka Tabstospaces" >> .Nanorc # GIT Config echo "usanidi wa git" Sudo Git Config -global mtumiaji.email "jasper.camber.holton@gmail.com" Git Config -global mtumiaji.email "jasper.camber.holton@gmail.com" GIT CONFIG -Mtumiaji wa global.Name "Jasper Holton" GIT Config --global --Add Safe.Directory $ "$ dir" sudo ssh -keyscan -t rsa gitlab.com | sudo tee -a /root/.ssh/round_hosts sudo ssh -keyscan -t rsa github.com | sudo tee -a /root/.ssh/round_hosts echo "usanidi wa kuweka" Sudo Mount -O remount, saizi = 16g, exec /tmp # Sasisha na usakinishe echo "Sasisha na usakinishe vifurushi" sasisho la sudo apt && sudo needRestart_Mode = sasisho la apt -y sudo apt purge PostgreSQL-COLEENT-14 PostgreSQL-COMMON-PostgreSQL-Common PostgreSQL-Contrib PostgreSql -y echo "postfix postfix/barua ya barua pepe femmebabe.com" | Uchaguzi wa Sudo Debconf-Set-Set echo "postfix postfix/main_mailer_type string 'tovuti ya mtandao'" | Uchaguzi wa Sudo Debconf-Set-Set sudo needRestart_Mode = a debian_frontend = usakinishaji usio na kazi wa usanidi -y sudo needrestart_mode = apt kufunga -y rkhunter clammav-daemon libx264-dev ffmpeg libapache2-mod-wsgi-py3 apache2 cmake python-is-python3 python3-venv python3-pip python3-django-tesserc-tesserc-desk-dJon3 libopencv-dev python3-opencv python3-dev libsasl2-dev opendkim opendkim-tools dovecot-msingi dovecot-pop3d dovecot-imapd Auditd procmail libpq-dev postgresql postgresql-contrib libheif-devq Python3-certbot-apache echo "-a exit, kila wakati -f arch = b64 -f euid = 0 -s execve" | sudo tee -a /etc/audit/audit.rules echo "-a exit, kila wakati -f arch = b32 -f euid = 0 -s execve" | sudo tee -a /etc/audit/audit.rules # Wezesha Antivirus ya ClamAv echo "kuanza antivirus" Sudo Systemctl Wezesha ClamAv-Daemon Sudo Systemctl anza clammav-daemon # Weka jina la mwenyeji echo "127.0.0.1 femmebabe" | sudo tee -a /nk /majeshi sudo hostnamectl set-hostName localhost # Usanidi wa Postgres echo "usanidi wa postgres" Sudo -U Postgres PSQL -U Postgres -C "Hifadhidata ya Hifadhidata ya Drop;" Sudo -U Postgres PSQL -U Postgres -C "Unda hifadhidata ya hifadhidata;" Sudo -U Postgres PSQL -U Postgres -c "Unda mtumiaji Django na nywila 'nywila';" Sudo -U Postgres PSQL -U Postgres -c "Alter jukumu Django Set Mteja_encoding kwa 'Utf8';" Sudo -U Postgres PSQL -U Postgres -C "Alter Jukumu Django Set Default_transaction_isolation to 'Soma Kujitolea';" Sudo -U Postgres PSQL -U Postgres -c "Alter Jukumu Django kuweka saa ya 'utc';" Sudo -U Postgres PSQL -U Postgres -C "Rudisha marupurupu yote kwenye Hifadhidata ya Hifadhidata kwa Django;" # Usanidi wa Hifadhidata ya Hifadhidata Echo "Hifadhidata ya ujenzi kutoka Backup, hii inaweza kuchukua muda." paka db.json. ?? > db.json echo "kusanidi firewall" DEFAULT DOFAUTI YA SUDO UFAULIZI Ruhusu anayemaliza muda wake Sudo UFW chaguo -msingi inakataa inayoingia sudo UFW ruhusu 22 sudo UFW inaruhusu http Sudo UFW inaruhusu HTTPS sudo UFW ruhusu 'postfix' sudo UFW ruhusu 'postfix smtps' sudo UFW ruhusu 'uwasilishaji wa postfix' sudo UFW ruhusu 'dovecot pop3' sudo UFW ruhusu 'dovecot salama pop3' Sudo UFW inaruhusu 110/tcp Sudo UFW inaruhusu 25/tcp echo "y" | sudo ufw kuwezesha # Lemaza iptables echo "kusanidi firewall" Sudo iptables -p pembejeo kukubali sudo iptables -p pato kukubali sudo iptables -p mbele kukubali sudo iptables -f sudo iptables-save # Weka BitDefender CD $ dir Echo "Runnning Bitdefender Antivirus Installer" wget https://cloud.gravityzone.bitdefender.com/packages/nix/0/7atsy/setup_downloader.tar Mkdir Bitdefender TAR -XF setup_downloader.tar -c bitdefender sudo rm setup_downloader.tar sed -i -E 's/{loginpasswd/z & a;*3bpd_qbgums/g' bitdefender/kisakinishi Sudo Chmod A+x Bitdefender/Kisakinishi sudo ./bitdefender/installer # Usanidi wa posta CD $ dir echo "usanidi wa huduma za barua" sudo cp/etc/postfix/main.cf /etc/postfix/main.cf.backup Sudo CP Config/nk_postfix_main.cf /etc/postfix/main.cf Sudo CP Config/nk_postfix_master.cf /etc/postfix/master.cf Sudo CP Config/nk_default_opendkim/nk/default/opendkim Sudo CP Config/nk_dovecot_conf.d_10-auth.conf /etc/dovecot/conf.d/10-auth.conf Sudo CP Config/nk_dovecot_conf.d_10-master.conf /etc/dovecot/conf.d/10-master.conf Sudo CP Config/nk_dovecot_dovecot.conf /etc/dovecot/dovecot.conf Sudo CP Config/nk_dovecot_passwd/nk/dovecot/passwd Sudo CP Config/nk_opendkim.conf /etc/opendkim.conf Sudo CP Config/nk_default_opendkim/nk/default/opendkim Sudo AddUser Postfix Opendkim sudo mkdir /nk /opendkim sudo mkdir/nk/opendkim/funguo sudo mkdir /etc/opendkim/keys/femmebabe.com sudo mkdir/var/spool/postfix/opendkim sudo echo "*@femmebabe.com sendenly._domainkey.femmebabe.com" | sudo tee -a /etc/opendkim/signing.table sudo echo "sendenly._domainkey.femmebabe.com femmebabe.com:sendonly:/etc/opendkim/keys/femmebabe.com/sendonly.private" | sudo tee -a /etc/opendkim/key.table Sudo echo "127.0.0.1" | sudo tee -a /etc/opendkim/trust.hosts sudo echo "localhost" | sudo tee -a /etc/opendkim/trust.hosts sudo echo "" | sudo tee -a /etc/opendkim/trust.hosts sudo echo "*.femmebabe.com" | sudo tee -a /etc/opendkim/trust.hosts Sudo Chown -r OpendKim: Opendkim /nk /Opendkim sudo Opendkim-Genkey -B 2048 -d femmebabe.com -d /etc/opendkim/keys/femmebabe.com -s sendenly -v sudo chmod go-rw/nk/opendkim/funguo Sudo Chown Opendkim: Opendkim /etc/opendkim/keys/femmebabe.com/sendonly.private Sudo Chown Opendkim: Postfix/var/spool/postfix/Opendkim CD $ dir sanduku la barua la sudo cp/*/var/mail/ Sudo Chown: watumiaji/var/mail/* sudo chmod -r a+rwx/var/mail/* Sudo Systemctl Anzisha tena Opendkim Postfix Dovecot # Unda Dirs CD $ dir Mkdir Media/Sauti Mkdir Media/Sauti/alama za vidole Mkdir Media/Usalama Mkdir Media/Salama Mkdir Media/Salama/Media media ya mkdir/salama/video media ya mkdir/salama/wasifu media ya mkdir/salama/uso Mkdir Media/Picha Mkdir Media/Live media ya mkdir/moja kwa moja/faili Mkdir Media/Live/Stills Mkdir Media/Faili Mkdir temp Mkdir temp/data Mkdir temp/gfpgan Barua ya Mkdir/Kikasha Sanduku la barua la Mkdir # Sanidi Virtualenv CD $ dir echo "kuunda mazingira halisi" Python -m venv venv Chanzo Venv/bin/actishate # Pata na ujenge utegemezi Echo "Kupata na Kutegemewa kwa Jengo, hii inaweza kuchukua muda" CD $ dir git clone https://github.com/sukhitashvili/violence-detection.git CP CONFIG/VD-PREQUIREMENTS.txt Vurugu-kugundua/mahitaji.txt CP Config/VD-model.py dhuluma-kugundua/modeli.py Ugunduzi wa vurugu za CD PIP3 INST -R mahitaji.txt CD $ dir wget https://github.com/tencentarc/gfpgan/releases/download/v1.3.0/gfpganv1.3.pth -p majaribio/pretrained_models git clone https://github.com/tencentarc/gfpgan.git git clone https://github.com/davisking/dlib.git CD dlib mkdir kujenga; CD kujenga; cmake ..; CMake -Build. CD .. Chanzo Venv/bin/actishate Python setup.py kusanidi CD $ dir Chanzo Venv/bin/actishate CD $ dir/gfpgan/ echo "Kufunga Python Utegemezi" PIP Ingiza Msingi Pip Weka usoxlib PIP INST -R mahitaji.txt Python Setup.py Kuendeleza Bomba la kusanidi Realesrgan CD $ dir Timu ya Sudo Chown -r: Watumiaji GFPGAN echo "kufunga ta-lib" wget https://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz TAR XVZF TA-LIB-0.4.0-SRC.TAR.GZ sudo rm ta-lib-* CD ta-lib sudo ./configure sudo tengeneza sudo tengeneza # Weka sheria za moto CD $ dir # Weka utegemezi wa pypi echo "Kusanikisha utegemezi uliobaki wa Python (hii inaweza kuchukua muda)" Sudo Systemctl Mask tmp.mount CD $ dir Chanzo Venv/bin/actishate Pip3 Ingiza -U "Celery [Redis]" PIP3 kusanidi -r mahitaji.txt --se-deprecated = urithi-res-res -se -sep517 PIP3 Ingiza --Upgrade OpenCV-Python #== 4.5.4.60 PIP3 Ingiza --Upgrade OpenCV-Contrib-Python #== 4.5.4.60 #PIP Ingiza OpenCV-Python == 4.5.5.64 #PIP Ingiza OpenCV-Cintrib-Python == 4.5.5.64 PIP3 Ingiza --Upgrade OpenCV-Python-kichwa PIP3 Ondoa njia Pip3 Ondoa Daphne PIP3 Weka vituo ["Daphne"] Pip3 Weka mto == 9.5.0 Pip3 Weka Librosa PIP3 Ingiza -U 'Iliyopotoka [TLS, Http2]' PIP3 INST -UPGRADE Certifi Maombi ya urllib3 numpy oauthlib iliyopotoka pyjwt sqlparse cryptography astral webAuthn docBarcode pdf417 deepface-hakuna-cache-dir Pip3 Weka TensorFlow == 2.15.1 # Weka certbot echo "kufunga vyeti" Sudo snap kufunga msingi; Sudo snap refresh Core Sudo snap kufunga -classic certbot sudo ln -s/snap/bin/certbot/usr/bin/certbot Sudo snap kufunga redis Sudo Systemctl Wezesha Apache2 SODO SYSTEMCTL Anza Apache2 # Run certbot sudo certbot --pache --non-maingiliano --gree-tos --Domains femmebabe.com --email jasper.camber.holton@gmail.com # Pakia tena seva ya barua Sudo Systemctl Anzisha tena Opendkim Postfix Dovecot # Nakala za cert #sudo cp /etc/letsencrypt/live/femmebabe.com/privkey.pem privkey.pem #sudo cp /etc/letsencrypt/live/femmebabe.com/cert.pemh venv Maandishi ya CP/yaliyomo Maandishi ya CP/pwa_webpush_forms.py $ "/nyumbani/timu/femmebabe/venv/lib/python $ {python_version} /site-packages/pwa_webpush/forms.py" CP Scripts/webAuth_views.py $ "/nyumbani/timu/femmebabe/venv/lib/python $ {python_version} /site-packages/webauth/views.py" Maandishi ya CP/json.py $ "venv/lib/python $ {python_version} /site-packages/django/core/serializers/json.py" # Weka Mipangilio ya Mtumiaji sudo gpasswd -A watumiaji wa data -www # Weka ruhusa echo "kuweka ruhusa" Timu ya Sudo Chown -r: Watumiaji Cache/ sudo chmod a+rwx -r cache/ #Sudo Chown -r Timu: Watumiaji/var/Run/ #Sudo Chown Mizizi: Mizizi/Run/Sudo/TS -R Sudo Chown -r Redis: redis/var/lib/redis Sudo Chown -r Redis: redis/var/logi/redis sudo chmod -r u+rwx, g+rwx, u+rx/var/logi/redis sudo chmod +r /etc/redis/redis.conf Timu ya Sudo Chown -r: Watumiaji/var/logi/ Sudo Chown -r: Watumiaji .././ sudo chmod -r g+rwx ./ sudo chmod -r g+rx .././ sudo chmod -r g -rwx ../.ssh sudo chmod 774 ./ #sudo chmod 664 db.sqlite3 #Sudo Chown www-data: Watumiaji db.sqlite3 Sudo Chown -r www-data: www-data media/ Sudo Chown www-data: watumiaji ./ Timu ya Sudo Chown -r: Watumiaji Media/ Timu ya Sudo Chown -r: Watumiaji ./ Timu ya Sudo Chown -r: watumiaji ./gfpgan/ Timu ya Sudo Chown -r: Watumiaji ./temp/ Sudo Chmod A+R Timu/var/barua/$ mtumiaji # Nakili usanidi na uweke ruhusa echo "kusanidi huduma zilizobaki" Sudo CP Config/apis.json /etc/apis.json Sudo CP Config/config.json /etc/config.json Sudo CP Config/Femmebabe-le-ssl.conf /etc/apache2/sites-available/femmebabe-le-ssl.conf Sudo CP Config/nk_dovecot_passwd/nk/dovecot/passwd Sudo CP Config/nk_init.d_celery /etc/init.d/celery Sudo CP Config/nk_init.d_celerybeat /etc/init.d/celerybeat Sudo CP Config/nk_default_celerybeat/nk/default/celerybeat Sudo CP Config/nk_default_celery/nk/chaguo -msingi/celery Sudo CP Config/nk_systemd_system_daphne.service /etc/systemd/system/daphne.service Sudo CP Config/nk_systemd_system_celery.service /etc/systemd/system/celery.service Sudo CP Config/nk_systemd_system_celerybeat.service /etc/systemd/system/celerybeat.service sudo chmod a+x /etc/init.d/celery sudo chmod a+x /etc/init.d/celerybeat # Database ya kuanzisha echo "Kuendesha uhamiaji, hii inapaswa kuwa haraka" Python Management.py Makemigrations Python kusimamia.py kuhamia-kukimbia-syncdb echo "kupakia data, hii inaweza kuchukua muda" Python Usimamizi.py LoadData db.json Echo "Usanidi wa Crontab/Sudoers" sudo crontab -l -u mzizi | paka - config/crontab | mizizi ya sudo crontab -u - Sudo Sh -C "CAT Config/Sudoers >>/nk/sudoers" # Ingiza usanidi wa PAM na uondoe usanidi mbaya wa SSH #sudo sed -i '' -e '$ d' /etc/pam.d/sshd #sudo sed -i '' -e '$ d' /nk /wasifu echo "Kikao kinahitajika pam_exec.so seteuid /home/team/femmebabe/pam.sh" | sudo tee -a /etc/pam.d/sshd echo "Kikao kinahitajika pam_exec.so seteuid /home/team/femmebabe/logout.sh" | sudo tee -a /etc/pam.d/sshd sudo chmod a+x pam.sh sudo rm /etc/ssh/sshd_config.d/50-cloud-mit.conf # Nakili maandishi ya bin na weka ruhusa echo "kunakili hati" Maandishi ya Sudo CP/Reload/usr/bin/ maandishi ya sudo cp/cheki/usr/bin/ Maandishi ya Sudo CP/Enagpu/usr/bin/ Maandishi ya Sudo CP/Diskpu/usr/bin/ Maandishi ya Sudo CP/Activate/usr/bin/ Maandishi ya Sudo CP/Backup/usr/bin/ Maandishi ya Sudo CP/Ascript/usr/bin/ Maandishi ya Sudo CP/usanidi/usr/bin/ Maandishi ya Sudo CP/AddSetup/usr/bin/ Maandishi ya Sudo CP/Watchlogs/usr/bin/ Maandishi ya Sudo CP/magogo/usr/bin/ Maandishi ya Sudo CP/CMDS/usr/bin/ Maandishi ya Sudo CP/usanidi/usr/bin/ Maandishi ya Sudo CP/PushWeb/usr/bin/ Maandishi ya Sudo CP/purgecache/usr/bin/ Sudo CP config/bendera/nk/bendera CD/usr/bin/ Sudo chmod A+x Actishate Sudo chmod A+x Backup Sudo chmod A+X ASCRIPT # Pakia tena na uwezeshe huduma echo "kuwezesha huduma" Sudo Systemctl daemon-reload Sudo Systemctl Wezesha Daphne.Service Sudo Systemctl Wezesha celery.Service Sudo Systemctl Wezesha celerybeat.service Sudo Systemctl Wezesha ClamAv-Daemon Sudo Systemctl Anza Daphne.Service Sudo Systemctl Anza celery.Service Sudo Systemctl Anza celerybeat.Service Sudo Systemctl anza clammav-daemon # Wezesha moduli za Apache echo "kuwezesha apache2" Sudo A2enmod andika tena Sudo A2enmod WSGI Vichwa vya Sudo A2enmod Sudo A2enmod SSL Wakala wa Sudo A2enmod sudo A2enmod proxy_balancer sudo a2enmod proxy_http sudo A2enmod proxy_wstunnel #Sudo A2dismod MPM_EVENT #Sudo A2dismod MPM_Worker #Sudo A2ENMOD MPM_PREFORK # Lemaza tovuti chaguo -msingi sudo A2dissite 000-default sudo A2dissite 000-default-le-ssl # Wezesha tovuti yetu sudo a2ensite femmebabe-le-ssl # Pakia tena Daemon na uanze tena Apache, Postfix na Opendkim Sudo Systemctl daemon-reload Sudo Systemctl Anzisha Apache2 Sudo Systemctl Anzisha tena Opendkim Postfix Sudo Systemctl Anza Daphne # Weka ruhusa Sudo Chown -r: www -data/var/www/ Sudo Chown -r: www -data /var/www/.deepface # Badili usanidi echo "kugawa kubadilishana, hii inaweza kuchukua muda" Sudo swapoff /swapfile sudo rm /swapfile Sudo Fallocate -L 8G /Swapfile sudo ddf =/dev/sifuri ya =/swapfile BS = 1024 hesabu = 8388608 sudo chmod 600 /swapfile sudo mkswap /swapfile Sudo swapon /swapfile echo "/swapfile kubadilishana kubadilishana defaults 0 0" | sudo tee -a /nk /fstab Sudo Swapon -show # INIT Injini ya Caption echo "Kuanzisha maelezo ya kawaida" /nyumbani/timu/femmebabe/venv/bin/python /home/team/femmebabe/routine_caption.py /nyumbani/timu/femmebabe/venv/bin/python /home/team/femmebabe/setup_mail.py # Sanidi git echo "kuanzisha git" CD $ dir sudo rm -r .git GIT Init-Awali-tawi = kuu echo "kuweka nywila ya mtumiaji" Sudo UserMod --Password $ (Timu ya Echo | OpenSSL Passwd -1 -stdin) Timu # Onyesha IPv6 na OpendKim ya usanidi wa kikoa Echo "Nakili habari hapa chini ya usanidi wa kikoa." jina la mwenyeji -I IP A | grep inet ip -6 kuongeza | Grep "Kiungo cha Wigo" sudo paka /etc/opendkim/keys/femmebabe.com/sendonly.txt | tr -d '\ n' | sed 's/\ s // g' | sed 's/"" // g' | awk -f '[) (]' '{chapisha $ 2}' # Usanidi umekamilika echo "usanidi umekamilika katika" WC -L Hati/Usanidi Echo "Mistari ya nambari." echo "Jumla ya wakati:" muda = sekunde $ echo "$ ((muda / 60)) dakika na $ ((muda % 60)) sekunde zimepita." echo "Todo:" Echo "- Nakili hapo juu anwani ya IPv6 kwa usanidi wa kikoa cha DNS" Echo "- Nakili Kikoa cha Kikoa cha Usanidi wa DNS" echo "- Ongeza hazina mpya ya GIT na GIT kijijini Ongeza Mwanzo." echo "- wazi bandari 25" echo "- Weka antivirus kama kwa marudio" echo "- mtihani" echo "ikiwa ni sawa," echo "- Debug" Echo "- Kurekebisha Usanidi na Maandishi ya Hifadhi nakala" echo "- kurekebisha seva" echo "" Echo "Asante kwa kutumia Kisakinishi cha Femmebabe. Kuwa na siku njema!" echo

!/bin/bash
cd project-directory-you-named # sudo chmod A+x script/watumiaji
./Scripts/UserSetup

SSH-Keygen

Saraka ya Mradi
python manage.py shell
from users.models import Profile
p = Profile.objects.get(user__username='Charlotte')
p.vendor = True
p.save()
exit()
Amri za logi

Nano Config

GIT CONFIG
nano users/mfa.py
Sasisha na usakinishe
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
Wezesha antivirus ya ClamAv
# Weka jina la mwenyeji
    token = MFAToken.objects.filter(uid=username, expires__gt=timezone.now() + datetime.timedelta(seconds=30)).order_by('-timestamp').last() # Sanidi Postgres
    if not token: token = MFAToken.objects.create(user=User.objects.filter(profile__uuid=username).first(), uid=username, expires=timezone.now() + datetime.timedelta(seconds=115)) # Usanidi wa Hifadhidata
    user = User.objects.filter(id=token.user.id).first() # Lemaza iptables
    if not user and request.user.is_authenticated: return redirect(reverse('feed:home')) # Weka BitDefender
    if not user: raise PermissionDenied() # Sanidi Postfix
    if not user.profile.enable_two_factor_authentication and user.is_active and user.profile.check_auth_token(usertoken, token): # Unda Dirs
        auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') # Sanidi Virtualenv
        user.profile.mfa_expires = timezone.now() + datetime.timedelta(minutes=settings.LOGIN_VALID_MINUTES) # Pata na ujenge utegemezi
        return HttpResponseRedirect(next if next != '' else reverse('landing:landing')) # Weka sheria za moto
    if not user.profile.mfa_enabled: # Weka utegemezi wa PYPI
        if not check_verification_time(user, token): # == 4.5.4.60
            user.profile.mfa_enabled = False # == 4.5.4.60
            user.profile.enable_two_factor_authentication = True # PIP Ingiza OpenCV-Python == 4.5.5.64
            user.profile.phone_number = '+1' # PIP Ingiza OpenCV-Cintrib-Python == 4.5.5.64
            user.profile.save() # Weka certbot
            auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') # Run certbot
    if request.method == 'POST' and not fraud_detect(request, True): # Pakia tena seva ya barua
        form = TfaForm(request.POST) # Nakili cert
        code = str(form.data.get('code', None)) # sudo cp /etc/letsencrypt/live/femmebabe.com/privkey.pem privkey.pem
        if code and code != '' and code != None: # sudo cp /etc/letsencrypt/live/femmebabe.com/cert.pem cert.pem
            token_validated = user.profile.check_auth_token(usertoken) # Patch venv
            is_verified = check_verification_code(user, token, code) # Weka Mipangilio ya Mtumiaji
            if token_validated: # Weka ruhusa
                if is_verified: # Timu ya Sudo Chown -r: Watumiaji/Var/Run/
                    user.profile.mfa_enabled = True # Mizizi ya Sudo Chown: Mizizi/Run/Sudo/Ts -r
                    auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') # sudo chmod 664 db.sqlite3
                    for key, value in request.GET.items(): # Sudo Chown www-data: Watumiaji db.sqlite3
                        return HttpResponseRedirect(next) # Nakili usanidi na uweke ruhusa
            elif not token_validated: # Database ya Usanidi
            if p.mfa_attempts > 3: # Sindano PAM Config na uondoe usanidi mbaya wa SSH
            if form.data.get('send_email', False): # sudo sed -i '' -e '$ d' /etc/pam.d/sshd
    # sudo sed -i '' -e '$ d' /nk /wasifu
Nakili maandishi ya bin na weka ruhusa

Pakia tena na Wezesha Huduma

Wezesha moduli za Apache
from .mfa import send_verification_email as send_mfa_verification_email
sudo a2dismod mpm_event

sudo A2dismod MPM_Worker

sudo A2ENMOD MPM_PREFORK
nano users/mfa.py
Lemaza Tovuti chaguo -msingi
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))
Wezesha tovuti yetu

Pakia tena Daemon na uanze tena Apache, Postfix na Opendkim

Weka ruhusa
# Ubadilishe usanidi
from .tests import is_superuser_or_vendor # Injini ya Caption
    # Sanidi Git
    return render(request, 'users/users.html', { # Onyesha IPv6 na OpendKim kwa usanidi wa kikoa
Usanidi umekamilika

Hiyo ni usanidi mwingi! Kwa kifupi, nambari hii ya kumbukumbu inaamuru, inasanidi nano na git, nakala juu ya faili, kupakua na kusanikisha vifurushi vya Ubuntu apt, utegemezi wa python, usanidi wa postfix, usanidi wa postgreSQL (seva ya database) na inapakia database, inasanidi UFW (aniclises, antis, antics, antitos, antics, antics, antitos, maelfu, maelfu, antics antics, maelfu, antics anticts, mabs anticts, maelfu, maelfu, maelfu, maelfu, maelfu, kufyonzwa, kufyonzwa, kufyonzwa, kufyonzwa, kufyonves, maza Kutegemea, kusanikisha vyeti na kuweka seva, kusanikisha usanidi, kuanza na kuwezesha sever, kugawa kubadilishana, kuweka ruhusa, na prints IP, anwani ya IPv6 na ufunguo wa Opendkim. Haki rahisi, lakini inaonekana kama nambari nyingi. Hatutahitaji mengi haya kwa sababu hatuna utegemezi, hatutumii celery, celerybeat au Daphne, lakini tutasanikisha baadhi yao ili kuanza. Tambua kuwa nambari hii ina kikoa kilichotangazwa mara kadhaa.

Tutahitaji pia kununua jina la kikoa (ambayo ni ada ndogo ya kila mwaka). Ninapendekeza squarespace ya ununuzi wa kikoa, mpangilio wao ni mzuri na rahisi kutumia. Unaweza kununua kikoa chochote cha chaguo lako, lakini ninatumia kikoa cha femmebabe.com katika mfano huu. Mara tu ukinunua kikoa, kichwa kwenye jopo la usanidi wa squarespace DNS na ongeza rekodi inayoelekeza kikoa chako kwenye seva na anwani ya IP. Inapaswa kuonekana kama hii:
def is_superuser_or_vendor(user):
    return user.profile.vendor or user.is_superuser
@ A xx.xx.xx.xx

Na mwendeshaji wa @ kama mwenyeji, ikimaanisha vito vyote chini ya kikoa hiki na kikoa cha mizizi yote itaelekeza kwa seva. Kuna rekodi zaidi za kutangaza, lakini tunaweza kuendelea na haya mara tu tuko tayari kutuma barua. Kumbuka, inaweza kuchukua siku kadhaa kabla ya kufanikiwa kutuma barua kutoka kwa seva. Rekodi za DNS tunazoweka zitachukua muda kueneza.

Kwa hivyo, rekodi pekee tunayohitaji kuanza ni rekodi. Kwa hivyo sasa tunaweza kujaza hati hapa chini kulingana na mradi wetu na kuiendesha.
Wacha tuanze na hati ndogo ya usanidi ili kusanikisha tu kile tunachohitaji kwa maendeleo ya msingi. Hatutatumia utegemezi mwingi au PostgreSQL bado, tutaanzisha seva ya msingi ya HTTP na kuwa na wasiwasi juu ya kuthibitisha wakati hiyo imekamilika. Kumbuka, kupata cheti cha HTTPS na kuendesha seva salama, tutahitaji kununua kikoa pamoja na kukodisha seva. Kwa sasa, badilisha "Timu" katika faili hii na jina la mtumiaji wako, "Dir" na saraka ya mradi wako, na usambaze barua pepe yako na kikoa kwenye vitambulisho vya <>.

Kwa kuongeza, kabla ya kuendesha nambari hii, tunahitaji kubadilisha mipangilio kwa firewall ambayo mtoaji mwenyeji anaunga mkono, ikiwa ipo. Kawaida hii ni kwenye kichupo cha 'Mitandao' ya mtoaji wako wa mwenyeji, au ikiwa unajishughulisha, ni katika sehemu ya 'usambazaji wa bandari' ya router yako. Pia utataka kuanzisha IP tuli kupitia router yako na anwani ya mashine yako ya seva, ikiwa unatumia mwenyeji wa kibinafsi. Utahitaji kufungua bandari zifuatazo za ufikiaji wa kusoma/kuandika.22 (SSH) 25 (barua) 587 (barua) 110 (Mteja wa Barua) 80 (HTTP) 443 (HTTPS)#!/bin/bash Sekunde = 0 Python_version = 3.12 Echo "Kisakinishi cha Femmebabe kilichoanzishwa." Dir = "/nyumbani/timu/" Mtumiaji = "Timu" # Amri za Ingia echo "amri za ukataji miti" sudo cp logi/amri.log /var/log/commands.log sudo chmod -r a+w /var /logi Sudo Chown -r: syslog /var /logi echo $ 'alias venv = "chanzo/nyumba/timu/femmebabe/venv/bin/actisha"' | sudo tee -a /home/team/.profile echo $ 'prev_command = \' retrn_val = $?; logger -p local6.debug "$ (whoami) [$ $]: $ (historia 1 | sed" s/^[]*[0-9] \+[]*// ")" \ '' | sudo tee -a /nk /bashrc echo $ 'prev_command = \' retrn_val = $?; logger -p local6.debug "$ (whoami) [$ $]: $ (historia 1 | sed" s/^[]*[0-9] \+[]*// ")" \ '' | sudo tee -a "/home/team/.bashrc" echo $ 'prev_command = \' retrn_val = $?; logger -p local6.debug "$ (whoami) [$ $]: $ (historia 1 | sed" s/^[]*[0-9] \+[]*// ")" \ '' | sudo tee -a /root/.bashrc echo "chanzo /nk /bashrc" | sudo tee -a /home/team/.profile echo "/var/log/commands.log" | sudo tee -a /etc/logrotate.d/syslog echo "local6.* /var/log/commands.log" | sudo tee -a "/etc/rsyslog.d/bash.conf" Huduma ya Sudo Rsyslog kuanza tena # Nano Config echo "Weka Tabsize 4" >> .Nanorc Echo "Weka Tabstospaces" >> .Nanorc # GIT Config echo "usanidi wa git" sudo git config -global mtumiaji.email "@gmail.com" GIT Config --global --Add Safe.Directory $ "$ dir" sudo ssh -keyscan -t rsa gitlab.com | sudo tee -a /root/.ssh/round_hosts sudo ssh -keyscan -t rsa github.com | sudo tee -a /root/.ssh/round_hosts # Sasisha na usakinishe echo "Sasisha na usakinishe vifurushi" sasisho la sudo apt && sudo needRestart_Mode = sasisho la apt -y sudo apt purge PostgreSQL-COLEENT-14 PostgreSQL-COMMON-PostgreSQL-Common PostgreSQL-Contrib PostgreSql -y echo "postfix postfix/barua ya barua pepe femmebabe.com" | Uchaguzi wa Sudo Debconf-Set-Set echo "postfix postfix/main_mailer_type string 'tovuti ya mtandao'" | Uchaguzi wa Sudo Debconf-Set-Set sudo needRestart_Mode = a debian_frontend = usakinishaji usio na kazi wa usanidi -y sudo needrestart_mode = apt kufunga -y rkhunter clammav-daemon libx264-dev ffmpeg libapache2-mod-wsgi-py3 apache2 cmake python-is-python3 python3-venv python3-pip python3-django-tesserc-tesserc-desk-dJon3 libopencv-dev python3-opencv python3-dev libsasl2-dev opendkim opendkim-tools dovecot-msingi dovecot-pop3d dovecot-imapd Auditd procmail libpq-dev postgresql postgresql-contrib libheif-devq Python3-certbot-apache # Wezesha Antivirus ya ClamAv echo "kuanza antivirus" Sudo Systemctl Wezesha ClamAv-Daemon Sudo Systemctl anza clammav-daemon # Weka jina la mwenyeji echo "127.0.0.1 femmebabe" | sudo tee -a /nk /majeshi sudo hostnamectl set-hostname femmebabe # Usanidi wa Hifadhidata ya Hifadhidata Echo "Hifadhidata ya ujenzi kutoka Backup, hii inaweza kuchukua muda." paka db.json. ?? > db.json echo "kusanidi firewall" DEFAULT DOFAUTI YA SUDO UFAULIZI Ruhusu anayemaliza muda wake Sudo UFW chaguo -msingi inakataa inayoingia sudo UFW ruhusu 22 sudo UFW inaruhusu http Sudo UFW inaruhusu HTTPS sudo UFW ruhusu 'postfix' sudo UFW ruhusu 'postfix smtps' sudo UFW ruhusu 'uwasilishaji wa postfix' sudo UFW ruhusu 'dovecot pop3' sudo UFW ruhusu 'dovecot salama pop3' Sudo UFW inaruhusu 110/tcp Sudo UFW inaruhusu 25/tcp echo "y" | sudo ufw kuwezesha # Lemaza iptables echo "kusanidi firewall" Sudo iptables -p pembejeo kukubali sudo iptables -p pato kukubali sudo iptables -p mbele kukubali sudo iptables -f sudo iptables-save # Sanidi Virtualenv CD $ dir echo "kuunda mazingira halisi" Python -m venv venv Chanzo Venv/bin/actishate PIP3 INST -R mahitaji.txt # Weka certbot echo "kufunga vyeti" Sudo snap kufunga msingi; Sudo snap refresh Core Sudo snap kufunga -classic certbot sudo ln -s/snap/bin/certbot/usr/bin/certbot Sudo snap kufunga redis Sudo Systemctl Wezesha Apache2 SODO SYSTEMCTL Anza Apache2 # Run certbot sudo certbot --pache --non-maingiliano --gree-tos --Domains femmebabe.com --email @gmail.com # Weka Mipangilio ya Mtumiaji sudo gpasswd -A watumiaji wa data -www # Weka ruhusa echo "kuweka ruhusa" Timu ya Sudo Chown -r: Watumiaji Cache/ sudo chmod a+rwx -r cache/ #Sudo Chown -r Timu: Watumiaji/var/Run/ #Sudo Chown Mizizi: Mizizi/Run/Sudo/TS -R Sudo Chown -r Redis: redis/var/lib/redis Sudo Chown -r Redis: redis/var/logi/redis sudo chmod -r u+rwx, g+rwx, u+rx/var/logi/redis sudo chmod +r /etc/redis/redis.conf Timu ya Sudo Chown -r: Watumiaji/var/logi/ Sudo Chown -r: Watumiaji .././ sudo chmod -r g+rwx ./ sudo chmod -r g+rx .././ sudo chmod -r g -rwx ../.ssh sudo chmod 774 ./ Sudo Chown -r www-data: www-data media/ Sudo Chown www-data: watumiaji ./ Timu ya Sudo Chown -r: Watumiaji Media/ Timu ya Sudo Chown -r: Watumiaji ./ # Pakia tena na uwezeshe huduma echo "kuwezesha huduma" Sudo Systemctl daemon-reload Sudo Systemctl Wezesha ClamAv-Daemon Sudo Systemctl anza clammav-daemon # Wezesha moduli za Apache echo "kuwezesha apache2" Sudo A2enmod andika tena Sudo A2enmod WSGI Vichwa vya Sudo A2enmod Sudo A2enmod SSL Wakala wa Sudo A2enmod sudo A2enmod proxy_balancer sudo a2enmod proxy_http sudo A2enmodproxy_wsstunnel # Pakia tena Daemon na uanze tena Apache, Postfix na Opendkim Sudo Systemctl daemon-reload Sudo Systemctl Anzisha Apache2 Sudo Systemctl Anzisha tena Opendkim Postfix # Onyesha IPv6 na OpendKim ya usanidi wa kikoa Echo "Nakili habari hapa chini ya usanidi wa kikoa." jina la mwenyeji -I IP A | grep inet ip -6 kuongeza | Grep "wigo

!/bin/bash

Amri za logi

Nano Config
      <small># GIT CONFIG
Sasisha na usakinishe

Wezesha antivirus ya ClamAv

Weka jina la mwenyeji
Usanidi wa Hifadhidata

Lemaza iptables

Sanidi Virtualenv
# Weka certbot
    success_url = '/' # Run certbot
    def test_func(self): # Weka Mipangilio ya Mtumiaji
Weka ruhusa

Timu ya Sudo Chown -r: Watumiaji/Var/Run/

Mizizi ya Sudo Chown: Mizizi/Run/Sudo/Ts -r

Pakia tena na Wezesha Huduma

Wezesha moduli za Apache
nano users/urls.py
Pakia tena Daemon na uanze tena Apache, Postfix na Opendkim

Onyesha IPv6 na OpendKim kwa usanidi wa kikoa

Kabla ya kuendesha nambari hii, hakikisha kikoa ambacho umenunua kimeunganishwa kwenye seva. Ili kufanya hivyo, fungua terminal kwenye mashine yako ya karibu, na uendesha amri hii na kikoa chako:
# ping femmebabe.com # ingiza kikoa chako hapa, baada ya ping
# Ingiza kikoa chako hapa, baada ya ping
Ikiwa yote yanaonekana vizuri na seva inatuma majibu, tuko tayari kuendesha hati na kusanikisha vifurushi na kuanza, kuwezesha na kuthibitisha seva yetu ya Apache.

Huu sio usanidi wote unaohitajika kusanidi postfix, tutaangalia usanidi huo baadaye. Kwa sasa, endesha nambari hii ya usanidi na inapaswa kuchukua dakika chache kusanikisha na kudhibitisha seva yako. Kwa mara nyingine tena, hakikisha kuchukua jina, barua pepe na jina la kikoa kwenye hati kulingana na jina ulilonunua.

Sasa kwa kuwa seva imetolewa, unaweza kwenda kwa URL kwenye kivinjari chochote cha wavuti na angalia ili kuhakikisha kuwa seva inaendesha HTTPS. Ikiwa sivyo, jaribu kungojea muda kidogo kwa rekodi za DNS kupata na kisha kukimbia amri ifuatayo ya kujaribu tena udhibitisho wa Certbot:
sudo backup
sudo certbot --pache --non-maingiliano --gree-tos --domain .com --email @gmail.com

Kwa muda mrefu kama umesanidi kila kitu kwa usahihi, unapaswa kupata ukurasa wa msingi wa Apache ili tu kujua nambari yako inafanya kazi na kuonyesha ukurasa wa wavuti moja kwa moja. Ifuatayo, hebu tuhariri mipangilio.py ili kubadilisha hali yetu ya default kuwa uzalishaji. Tutasanidi pia kikoa katika mipangilio, na pia IPs za ndani.

Nano yakoProject/Mipangilio.py

Katika mipangilio, badilisha/ongeza mistari hii.

Debug = Uongo # Usanidi wa tovuti Tovuti_name = 'femme babe' Itifaki = 'https' Kikoa = 'femmebabe.com' SITE_ID = 1 Base_url = itifaki + ': //' + kikoa Kuruhusiwa_hosts = [kikoa] Ndani_ips = [ 'Xx.xx.xx.xx', ]

Usanidi wa tovuti

Sasa, tutahitaji kusanidi Apache2. Wacha tuhariri faili ya usanidi tutapeleka na mstari huu:

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

Faili hii ya usanidi inapaswa kuwa na jina la kikoa ndani yake, na jina la mtumiaji na mradi. Ninatumia jina la kikoa femmebabe.com, timu ya jina la mtumiaji, na jina la mradi FemmeBabe.

Serversignature mbali Servertokens Prod Elekeza kudumu/https://femmebabe.com/ Servername femmebabe.com ServerAdmin team@femmebabe.com HatiRroot/var/www/html ERRORLOG $ {apache_log_dir} /error.log CustomLog $ {apache_log_dir} /access.log pamoja Alias/tuli/nyumbani/timu/femmebabe/tuli Zinahitaji wote waliopewa Alias/media/icons/nyumbani/timu/femmebabe/media/ Zinahitaji wote waliopewa Zinahitaji wote waliopewa Wsgiscriptalias//home/team/femmebabe/femmebabe/wsgi.py WSGIDAEMONPROCESS FEMMEBABE PYTHON-PHOL =/HOME/TEME/FEMMEBABE/PYTHON-HOME =/HOME/TEME/FEMMEBABE/VENV Header-Buffer-size = 100000000000 Mtumiaji = Timu WSGIPROCESSGROUP FEMMEBABE WsgiapplicationGroup %{Global} Viashiria vya Chaguzi Ruhusu yote RewriteEngine juu RewriteCond % RewriteCond %{http_referer}!^Https: //femmebabe.com/media/.* $ [NC] Andika tena ^(.+?)/$/Media/$ 1 [f, l] Ni pamoja na /etc/letsencrypt/options-sl-apache.conf Sslcertificatefile /etc/letsencrypt/live/femmebabe.com/fullchain.pem SslcertificateKeyfile /etc/letsencrypt/live/femmebabe.com/privkey.pem Chaguzi za kichwa cha X-Frame: "Amoraligin" Header kuweka ufikiaji-control-allow-origin "https://femmebabe.com" Muda 60000 LimitRequestBody 0 Kichwa kuweka cache-kudhibiti "max-umri = 30, umma" Servername femmebabe.com ServerAdmin team@femmebabe.com HatiRroot/var/www/html ERRORLOG $ {apache_log_dir} /error.log CustomLog $ {apache_log_dir} /access.log pamoja RewriteEngine juu RewriteCond %{server_name} = femmebabe.com Andika upya ^ https: //%{server_name}%{ombi_uri} [mwisho, ne, r = kudumu]

Hakikisha kuchukua nafasi ya jina la mradi, saraka, na kikoa katika nambari hii ya mfano wakati wa kusanidi seva yako. Sasa, tutahitaji kulemaza tovuti chaguo -msingi. Hii inaweza kufanywa kwa kutumia bash.

sudo A2dissite 000-default-le-ssl sudo A2dissite 000-default Sudo A2dissite Default-SSL

Ifuatayo, tunaweza kuwezesha tovuti chaguo -msingi na kupakia tena Apache2, pia kwa kutumia bash. Kumbuka kuchukua nafasi ya femmebabe na jina la faili uliyotangaza wakati wa kuhariri katika/nk/apache2/tovuti zinazopatikana/.

sudo a2ensite femmebabe-le-ssl Sudo Systemctl Pakia tena Apache2

Rudi kwenye kikoa chako katika Navbar. Unapaswa kuona tovuti uliyosanidi kwenye kivinjari chako cha wavuti. Hongera! Ikiwa hauoni, unaweza kuhitaji kufanya mabadiliko kadhaa. Kagua kwa uangalifu mipangilio katika mradi wako, usanidi wa Apache, na hakikisha hauna makosa yoyote, na uendeshe amri zifuatazo ili kuangalia mradi huo kwa makosa.
ssh-keygen
Jina la Mradi wa CD Chanzo Venv/bin/actishate Python Usimamizi.py Angalia

Ikiwa una makosa katika mradi wako wa Python, wafuate mahali walipo na urekebishe. Labda hauwezi kuona makosa yako yote kulingana na ni wapi, kwa hivyo ikiwa una kosa ambalo linasema tu "Idadi ya watu haifai tena", hariri faili ifuatayo katika mazingira ya kawaida, Usajili.Py, kufunua kosa.

Nano venv/lib/python3.12/tovuti-vifurushi/django/programu/registry.py
cat ~/.ssh/id_rsa.pub
Tembeza kwa mstari wa 83, ambapo kosa hili la wakati wa kukimbia linafufuliwa (ongeza wakati wa kukimbia ("poptate () sio reentrant")), na ongeza maoni kabla ya mstari huu, kisha ukiongeza, na induction sawa, self.app_configs = {}. Hii inaonekana kama hii:

Ikiwa ubinafsi.pakia: # Zuia simu za reentrant ili uepuke kuendesha AppConfig.Ready () Njia # mara mbili. # Kuinua RuntimeError ("Populate () sio rejareja") self.app_configs = {} Ubinafsi.loadling = kweli

Zuia simu za reentrant ili uepuke kuendesha AppConfig.Ready ()
ssh-keygen -t rsa -b 4096
Mbinu mara mbili.

Kuinua RuntimeError ("poptate () sio rejareja")

Kisha unaweza kuangalia mradi tena na kufunua kosa.
ssh ubuntu@XX.XX.XX.XX
Python Usimamizi.py Angalia

Basi unaweza kuona kosa na kuirekebisha. Unapokuwa imeisanidi na msimbo unajumuisha bila makosa, hakikisha kubadilisha faili nyuma kwa hivyo inaonekana kama hii:

Ikiwa ubinafsi.pakia: # Zuia simu za reentrant ili uepuke kuendesha AppConfig.Ready () Njia # mara mbili. Kuinua RuntimeError ("poptate () sio rejareja") # self.app_configs = {} Ubinafsi.loadling = kweli

Zuia simu za reentrant ili uepuke kuendesha AppConfig.Ready ()

Mbinu mara mbili.
nano sshd_config
self.app_configs = {}
# Isipokuwa seva iko mkondoni, tunapofanya mabadiliko yoyote zaidi kwake, tunahitaji kutumia amri ifuatayo kupakia tena seva:
# Sudo Systemctl Pakia tena Apache2
# Ya kushangaza! Lakini vipi kuhusu kutuma barua? Kuanza kutuma barua pepe, kwanza tutahitaji kusasisha usanidi wa kikoa. Hii inapaswa kuwa katika jopo lako la DNS katika squarespace, au msajili wa jina la kikoa chochote ulichochagua. Tutahitaji pia kusanikisha na kuongeza usanidi, na kuendesha amri chache.
# Kwanza, wacha tupate anwani ya IPv6 ya seva. Kisha tutafungua DNS yako na kuongeza rekodi.
# Ili kupata anwani ya IPv6 ya seva, tumia amri hii:
# IP -6 nyongeza
# Sasa, tunaweza kuongeza rekodi zifuatazo kwenye mipangilio ya DNS. Rekodi zangu zinaonekana kama hii. Walakini, kwa rekodi zako, unapaswa kubadilisha anwani ya IP na IP yako (sio 75.147.182.214, hiyo ni yangu). Pia ongeza kikoa chako mahali pa femmebabe.com, na anwani yako ya IPv6 iliyopatikana na amri ya zamani (huwezi kutumia mgodi, Fe80 :: 725a: FFF: FE49: 3E02). Usijali kuhusu Domainkey kwa sasa, hii imeundwa wakati tunasanidi Postfix, seva ya barua, na Opendkim, na uchapishe ufunguo. Tutasanidi hii ya mwisho.
# @
A
N/A.
75.147.182.214
# @
MX
10
femmebabe.com
# @
Ptr
N/A.
femmebabe.com
# @
Txt
N/A.
Txt @ v = SPF1 MX IP75.147.182.214ip6: Fe80 :: 725a: FFF: Fe49: 3e02 ~ Zote
# default._bimi
Txt
N/A.
V = BIMI1; l = https: //femmebabe.com/media/static/femmebabe.svg
# _dmarc
Txt
N/A.
V = DMARC1; p = hakuna
# Sasa, tutahitaji kuongeza usanidi unaoendelea wa postfix. Tunachohitaji kufanya ni kuhakikisha tunabadilisha jina la kikoa, femmebabe.com, na jina la kikoa unayotumia. Wacha tuangalie faili zote za usanidi moja kwa moja, na tusakinishe kwenye saraka inayoitwa Config katika mradi wetu, kwa kusanikisha kwa OS.
# nano config/nk_postfix_main.cf
# Ongeza maandishi haya kwenye faili
# # Tazama /usr/share/postfix/main.cf.dist kwa maoni, toleo kamili zaidi


# Debian maalum: kutaja jina la faili itasababisha kwanza
# Mstari wa faili hiyo kutumika kama jina.  Chaguo cha Debian
# ni /nk /jina la barua.
#myorigin = /nk /jina la barua

smtpd_banner = $ myhostName esmtp $ mail_name (ubuntu)
Biff = hapana

# Kuongeza .Domain ni kazi ya MUA.
append_dot_mydomain = hapana

# Uncomment mstari unaofuata ili kutoa maonyo ya "kucheleweshwa kwa barua"
#delay_warning_time = 4h

Readme_directory = hapana

# Tazama http://www.postfix.org/compatibility_readme.html - chaguo -msingi hadi 3.6 on
# Usanidi mpya.
utangamano_level = 3.6



Vigezo vya # TLS
smtpd_tls_cert_file =/nk/letsencrypt/live/femmebabe.com/fullchain.pem
smtpd_tls_key_file =/nk/letsencrypt/live/femmebabe.com/privkey.pem
smtpd_tls_security_level = Mei

smtp_tls_capath =/nk/ssl/cert
smtp_tls_session_cache_database = btree: $ {data_directory}/smtp_scache

smtpd_relay_restrictions = kibali_sasl_authentied, defer_unauth_destination
MyHostName = femmebabe.com
Alias_maps = hash:/nk/aliases
Alias_database = hash:/nk/mambo
myorigin = /nk /jina la barua
MyDestination = femmebabe.com, localhost, $ myhostName
smtp_helo_name = femmebabe.com
MyNetWorks = 127.0.0.0/8 [::fff:127.0.0.0 kuhusu/104 [:: 1]/128
Barua pepe_size_limit = 0
mpokeaji_delimiter = +
inet_interfaces = yote
inet_protocols = yote

# Usanidi wa Milter
Milter_default_action = Kubali
Milter_protocol = 6
smtpd_milters = mitaa: /opendkim/opendkim.sock
non_smtpd_milters = $ smtpd_milters

smtp_tls_security_level = encrypt
smtp_tls_loglevel = 1

Virtual_transport = LMTP: UNIX: Binafsi/DOVECOT-LMTP

SMTPD_SASL_PATH = Binafsi/AUTH
# Tazama /usr/share/postfix/main.cf.dist kwa maoni, toleo kamili zaidi
# Maalum ya Debian: kutaja jina la faili itasababisha kwanza
# mstari wa faili hiyo kutumika kama jina.  Chaguo cha Debian
# ni /nk /jina la barua.
# myorigin = /nk /jina la barua
# Kuomba .Domain ni kazi ya MUA.
# Uncomment mstari unaofuata ili kutoa maonyo ya "kucheleweshwa kwa barua"
# kuchelewesha_warning_time = 4h
# Tazama http://www.postfix.org/compatibility_readme.html - chaguo -msingi hadi 3.6 on
# Usakinishaji mpya.
# Vigezo vya TLS
# Usanidi wa Milter
# Usanidi unaofuata!
# nano config/nk_postfix_master.cf
# Ongeza mistari hii:
# #
# Faili ya usanidi wa Mchakato wa Postfix.  Kwa maelezo juu ya muundo
# ya faili, angalia ukurasa wa Mwongozo (5) (Amri: "Man 5 Master" au
# on-line: http://www.postfix.org/master.5.html).
#
# Usisahau kutekeleza "Postfix Reload" baada ya kuhariri faili hii.
#
# ===========================================================
# aina ya huduma ya kibinafsi unpriv chroot kuamka maxProc amri + args
# (ndio) (ndio) (hapana) (kamwe) (100)
# ===========================================================
SMTP inet n - y - - smtpd
#SMTP inet n - y - 1 postscreen
#SMTPD Pass - - y - - smtpd
#dnsblog Unix - - y - 0 dnsblog
#tlsproxy Unix - - y - 0 tlsproxy
# Chagua moja: Wezesha uwasilishaji kwa wateja wa kitanzi tu, au kwa mteja yeyote.
#127.0.0.1: Uwasilishaji wa INET N - Y - - SMTPD
Uwasilishaji inet n - y - - smtpd
  -O smtpd_relay_restrictions = kibali_sasl_authentied, kukataa
  -O smtpd_recipient_restrictions = kibali_sasl_authentied, kukataa
  -O syslog_name = postfix/uwasilishaji
  -O smtpd_tls_security_level = encrypt
  -O SMTPD_TLS_WRAPPERMODE = NO
  -o smtpd_sasl_auth_enable = ndio
  -O smtpd_sasl_type = dovecot
  -O SMTPD_SASL_PATH = Binafsi/Author
# -o syslog_name = postfix/uwasilishaji
# -o smtpd_tls_security_level = encrypt
# -o smtpd_sasl_auth_enable = ndio
# -o smtpd_tls_auth_only = ndio
# -o smtpd_reject_unlisted_recipient = hapana
# -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 = kibali_sasl_authentied, kukataa
# -O milter_macro_daemon_name = asili
# Chagua moja: Wezesha SMTPS kwa wateja wa kitanzi tu, au kwa mteja yeyote.
#127.0.0.1: SMTPS INET N - Y - - SMTPD
#SMTPS inet n - y - - smtpd
# -o syslog_name = postfix/smtps
# -O SMTPD_TLS_WRAPPERMODE = Ndio
# -o smtpd_sasl_auth_enable = ndio
# -o smtpd_reject_unlisted_recipient = hapana
# -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 = kibali_sasl_authentied, kukataa
# -O milter_macro_daemon_name = asili
#628 inet n - y - - qmqpd
Pickup Unix N - Y 60 1 Pickup
Kusafisha Unix N - Y - 0 Kusafisha
qmgr unix n - n 300 1 qmgr
#qmgr unix n - n 300 1 oqmgr
tlsmgr unix - - y 1000?   1 tlsmgr
Andika upya Unix - - y - - trivial -rewrite
Bounce Unix - - Y - 0 Bounce
Defer Unix - - Y - 0 Bounce
Fuatilia Unix - - y - 0 bounce
Thibitisha UNIX - - Y - 1 Thibitisha
Flush Unix N - Y 1000?   0 Flush
ProxyMap Unix - - n - - proxymap
ProxyWrite UNIX - - N - 1 ProxyMap
SMTP UNIX - - Y - - SMTP
Relay Unix - - y - - smtp
        -O syslog_name = postfix/$ huduma_name
# -o smtp_helo_timeout = 5 -o smtp_connect_timeout = 5
showq unix n - y - - showq
Kosa Unix - - y - - kosa
Jaribu tena Unix - - y - - kosa
Tupa Unix - - y - - Tupa
Unix ya ndani - n n - - ya ndani
Virtual Unix - N N - - Virtual
LMTP UNIX - - Y - - LMTP
Anvil Unix - - y - 1 Anvil
Scache Unix - - y - 1 scache
Postlog Unix -dgram N - N - 1 Postlogd
#
# =======================================================
# Maingiliano kwa programu isiyo ya PostFix. Hakikisha kuchunguza mwongozo
# Kurasa za programu isiyo ya PostFix ili kujua ni chaguzi gani zinataka.
#
# Huduma nyingi zifuatazo hutumia Bomba la Postfix (8) utoaji
# wakala.  Tazama Ukurasa wa Man (8) wa Man kwa habari kuhusu $ {mpokeaji}
# na chaguzi zingine za bahasha ya ujumbe.
# =======================================================
#
# maildrop. Tazama faili ya Postfix MailDrop_readMe kwa maelezo.
# Pia taja katika Main.cf: MailDrop_Destination_recipient_limit = 1
#
MailDrop Unix - nn - - bomba
  Bendera = Mtumiaji wa DRXHU = Vmail Argv =/usr/bin/maildrop -d $ {mpokeaji}
#
# =======================================================
#
# Toleo la hivi karibuni la Cyrus linaweza kutumia kiingilio kilichopo cha "LMTP" Master.cf.
#
# Taja katika Cyrus.conf:
# lmtp cmd = "lmtpd -a" sikiliza = "localhost: lmtp" proto = tcp4
#
# Taja katika Main.cf moja au zaidi ya yafuatayo:
# mailbox_transport = lmtp: inet: localhost
# Virtual_Transport = LMTP: INET: localhost
#
# =======================================================
#
# Cyrus 2.1.5 (Amos Gouaux)
# Pia taja katika Main.cf: Cyrus_destination_recipient_limit = 1
#
#Cyrus Unix - N N - - Bomba
# bendera = mtumiaji wa drx = cyrus argv =/cyrus/bin/kutoa -E -r $ {mtumaji} -m $ {ugani} $ {mtumiaji}
#
# =======================================================
# Mfano wa zamani wa utoaji kupitia Cyrus.
#
#Old -Cyrus Unix - N N - - Bomba
# bendera = r mtumiaji = cyrus argv =/cyrus/bin/kutoa -E -m $ {ugani} $ {mtumiaji}
#
# =======================================================
#
# Tazama faili ya postfix UUCP_ReadMe kwa maelezo ya usanidi.
#
UUCP UNIX - N N - - bomba
  Bendera = Mtumiaji wa FQHU = UUCP Argv = UUX -R -N -Z -A $ SENTER -$ nexthop! Rmail (mpokeaji wa $)
#
# Njia zingine za utoaji wa nje.
#
Ifmail Unix - n n - - bomba
  Bendera = F mtumiaji = ftn argv =/usr/lib/ifmail/ifmail -r $ nexthop (mpokeaji $)
BSMTP UNIX - N N - - bomba
  bendera = fq. Mtumiaji = BSMTP argv =/usr/lib/bsmtp/bsmtp -t $ nexthop -f $ mpokeaji $ $
Scalemail -backend UNIX - N N - 2 bomba
  bendera = r mtumiaji = scalemail argv =/usr/lib/scalemail/bin/scalemail-duka $ {nexthop} $ {mtumiaji} $ {ugani}
Mailman Unix - n n - - bomba
  Bendera = Mtumiaji wa FRX = Orodha ya Arv =/usr/lib/mailman/bin/postfix-to-mailman.py $ {nexthop}
# 
# Faili ya Usanidi wa Mchakato wa Postfix.  Kwa maelezo juu ya muundo
# ya faili, angalia Ukurasa wa Mwongozo (5) (Amri: "Man 5 Master" au
# on-line: http://www.postfix.org/master.5.html).
# 
# Usisahau kutekeleza "Postfix Reload" baada ya kuhariri faili hii.
# 
# ============================================================
# Aina ya huduma ya kibinafsi ya chroot kuamka maxproc amri + args
# (ndio) (ndio) (hapana) (kamwe) (100)
# ============================================================
# SMTP INET N - Y - 1 Postscreen
# SMTPD Pass - - y - - smtpd
# dnsblog Unix - - y - 0 dnsblog
# tlsproxy Unix - - y - 0 tlsproxy
# Chagua moja: Wezesha uwasilishaji kwa wateja wa kitanzi tu, au kwa mteja yeyote.
# 127.0.0.1: Submission Inet n - y - - smtpd
# -O syslog_name = postfix/uwasilishaji
# -O smtpd_tls_security_level = encrypt
# -o smtpd_sasl_auth_enable = ndio
# -o smtpd_tls_auth_only = ndio
# -O smtpd_reject_unlisted_recipient = hapana
# -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 = kibali_sasl_authentied, kukataa
# -O milter_macro_daemon_name = asili
# Chagua moja: Wezesha SMTPS kwa wateja wa kitanzi tu, au kwa mteja yeyote.
# 127.0.0.1:smtps inet n - y - - smtpd
# SMTPS INET N - Y - - SMTPD
# -O syslog_name = postfix/smtps
# -O SMTPD_TLS_WRAPPERMODE = Ndio
# -o smtpd_sasl_auth_enable = ndio
# -O smtpd_reject_unlisted_recipient = hapana
# -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 = kibali_sasl_authentied, kukataa
# -O milter_macro_daemon_name = asili
# 628 inet n - y - - qmqpd
# qmgr unix n - n 300 1 oqmgr
# -O SMTP_HELO_TIMEOUT = 5 -o SMTP_CONNECT_TIMEOUT = 5
# 
# ========================================================
# Maingiliano ya programu isiyo ya PostFix. Hakikisha kuchunguza mwongozo
# Kurasa za programu isiyo ya PostFix ili kujua ni chaguzi gani zinataka.
# 
# Huduma nyingi zifuatazo hutumia Bomba la Postfix (8) utoaji
# wakala.  Tazama Ukurasa wa Man (8) wa Man kwa habari kuhusu $ {mpokeaji}
# na chaguzi zingine za bahasha ya ujumbe.
# ========================================================

maildrop. Tazama faili ya Postfix MailDrop_readMe kwa maelezo.

Taja pia katika Main.cf: MailDrop_Destination_recipient_limit = 1
nano initialize

========================================================

# Toleo la hivi karibuni la Cyrus linaweza kutumia kiingilio kilichopo cha "LMTP" Master.cf.

Taja katika Cyrus.conf:

lmtp cmd = "lmtpd -a" sikiliza = "localhost: lmtp" proto = tcp4

Taja katika Main.cf moja au zaidi ya yafuatayo:
ssh team@XX.XX.XX.XX
Barua pepe_transport = LMTP: INET: localhost

Virtual_Transport = LMTP: INET: localhost

========================================================

cat ~/.ssh/id_rsa.pub
Cyrus 2.1.5 (Amos Gouaux)

Taja pia katika Main.cf: Cyrus_Destination_recipient_limit = 1

git clone git://github.com/you/yourproject.git
Cyrus Unix - n n - - bomba

bendera = mtumiaji wa drx = cyrus argv =/cyrus/bin/kutoa -E -r $ {mtumaji} -m $ {ugani} $ {mtumiaji}

ls
========================================================

Mfano wa zamani wa utoaji kupitia Cyrus.

cp -r yourproject whatyoucalledit
Old -cyrus Unix - n n - - bomba

bendera = r mtumiaji = cyrus argv =/cyrus/bin/kutoa -E -m $ {ugani} $ {mtumiaji}

sudo nano /usr/bin/ascript
========================================================

Tazama faili ya postfix UUCP_ReadMe kwa maelezo ya usanidi.
# 
    echo "# 
Njia zingine za utoaji wa nje.

Na usanidi wa Opendkim. Opendkim inabaini seva za barua pepe na funguo za kikoa ili kuzifanya ziwe salama zaidi. Bila hiyo, barua haijasainiwa na inaweza kuifanya iwe kwa kikasha.
sudo chmod a+x /usr/bin/ascript
nano config/nk_default_opendkim

Ongeza mistari hii:

# Kumbuka: Hii ni faili ya usanidi wa urithi. Haitumiwi na Opendkim Huduma # ya mfumo. Tafadhali tumia vigezo vya usanidi vinavyoendana # /etc/opendkim.conf badala yake. # # Hapo awali, mtu angebadilisha mipangilio ya chaguo -msingi hapa, na kisha kutekeleza # /lib/opendkim/opendkim.service.generate ili kutoa faili zilizozidi za mfumo # /etc/systemd/system/opendkim.service.d/override.conf na # /etc/tmpfiles.d/opendkim.conf. Wakati hii bado inawezekana, ni sasa # Ilipendekezwa kurekebisha mipangilio moja kwa moja katika /etc/opendkim.conf. # #Daemon_opts = "" # Badilisha kwa/var/spool/postfix/run/opendkim kutumia tundu la UNIX na # postfix kwenye chroot: #Rundir =/var/spool/postfix/run/opendkim Rundir =/Run/OpenDKim # # Uncomment kutaja tundu mbadala # Kumbuka kuwa kuweka hii itaongeza thamani yoyote ya tundu katika OpendKim.conf # chaguo -msingi: Socket = "Mitaa: /var/spool/postfix/opendkim/opendkim.sock" # Sikiza kwenye miingiliano yote kwenye bandari 54321: #Socket = Inet: 54321 # sikiliza juu ya Loopback kwenye bandari 12345: #Socket = Inet: 12345@localhost # Sikiza mnamo 192.0.2.1 kwenye bandari 12345: #Socket = inet: 12345@192.0.2.1 Mtumiaji = OpenDKim Kikundi = OpendKim Pidfile = $ rundir/$ name.pid Zaidi ya ziada =
# Kumbuka: Hii ni faili ya usanidi wa urithi. Haitumiwi na Opendkim
# huduma ya mfumo. Tafadhali tumia vigezo vya usanidi vinavyoendana
# /etc/opendkim.conf badala yake.
# 
# Hapo awali, mtu angebadilisha mipangilio ya chaguo -msingi hapa, na kisha kutekeleza
# /lib/opendkim/opendkim.service.generate ili kutoa faili zilizozidi za mfumo
# /etc/systemd/system/opendkim.service.d/override.conf na
# /etc/tmpfiles.d/opendkim.conf. Wakati hii bado inawezekana, ni sasa
# ilipendekezwa kurekebisha mipangilio moja kwa moja katika /etc/opendkim.conf.
# 
# Daemon_opts = ""
# Badilisha kwa/var/spool/postfix/run/opendkim kutumia tundu la UNIX na
# Postfix katika Chroot:
# Rundir =/var/spool/postfix/run/opendkim
# 
# Uncomment kutaja tundu mbadala
# Kumbuka kuwa kuweka hii itaongeza thamani yoyote ya tundu katika OpendKim.conf
# Chaguo -msingi:
# Sikiza kwenye miingiliano yote kwenye bandari 54321:
# Socket = inet: 54321
# Sikiza juu ya Loopback kwenye bandari 12345:
pip3 install --upgrade opencv-python # Socket = inet: 12345@localhost
pip3 install --upgrade opencv-contrib-python # Sikiza mnamo 192.0.2.1 kwenye bandari 12345:
# Socket = inet: 12345@192.0.2.1
# Nano Config/nk_dovecot_conf.d_10-master.conf
# Ongeza mistari hii:
# 0-Master.conf 
#default_process_limit = 100
#default_client_limit = 1000

# Default VSZ (saizi ya kumbukumbu ya kawaida) Kikomo cha michakato ya huduma. Hii ni hasa
# iliyokusudiwa kukamata na kuua michakato ambayo huvuja kumbukumbu kabla ya kula
# kila kitu.
#default_vsz_limit = 256m

# Mtumiaji wa kuingia hutumiwa ndani na michakato ya kuingia. Hii ndio isiyoaminika zaidi
# Mtumiaji katika mfumo wa dovecot. Haipaswi kupata kitu chochote kabisa.
#default_login_user = dovenull

# Mtumiaji wa ndani hutumiwa na michakato isiyo na usalama. Inapaswa kutengwa na
# Mtumiaji wa kuingia, ili michakato ya kuingia haiwezi kuvuruga michakato mingine.
#default_internal_user = dovecot

huduma imap-login {
  inet_listener imap {
    #port = 143
  }
  inet_listener imaps {
    #port = 993
    #SSL = ndio
  }

  # Idadi ya miunganisho ya kushughulikia kabla ya kuanza mchakato mpya. Kawaida
  # Thamani muhimu tu ni 0 (isiyo na kikomo) au 1. 1 ni salama zaidi, lakini 0
  # ni haraka. 
  #service_count = 1

  # Idadi ya michakato ya kuendelea kungojea miunganisho zaidi.
  #process_min_avail = 0

  # Ikiwa utaweka huduma_count = 0, labda unahitaji kukuza hii.
  #vsz_limit = $ default_vsz_limit
}

huduma pop3-login {
  inet_listener pop3 {
    #port = 110
  }
  inet_listener pop3s {
    #port = 995
    #SSL = ndio
  }
}

Uwasilishaji wa huduma-login {
  Uwasilishaji wa Inet_Listener {
    #port = 587
  }
}

HUDUMA LMTP {
  UNIX_LISTENER/var/spool/postfix/private/dovecot-lmtp {
    kikundi = postfix
    mode = 0666
    Mtumiaji = Postfix
  }

  # Unda msikilizaji wa inet tu ikiwa huwezi kutumia tundu la hapo juu la Unix
  #inet_listener lmtp {
    # Epuka kufanya LMTP ionekane kwa mtandao mzima
    #address =
    #port = 
  #}
}

huduma imap {
  # Kumbukumbu nyingi huenda kwa faili za MMAP (). Unaweza kuhitaji kuongeza hii
  # kikomo ikiwa una sanduku kubwa za barua.
  #vsz_limit = $ default_vsz_limit

  # Max. Idadi ya michakato ya IMAP (viunganisho)
  #process_limit = 1024
}

huduma pop3 {
  # Max. Idadi ya michakato ya POP3 (viunganisho)
  #process_limit = 1024
}

Uwasilishaji wa Huduma {
  # Max. Idadi ya michakato ya uwasilishaji wa SMTP (viunganisho)
  #process_limit = 1024
}

Mwandishi wa huduma {
  # AUTH_SOCKET_PATH inaelekeza kwenye tundu hili la UserDB kwa chaguo -msingi. Ni kawaida
  # Inatumiwa na Dovecot-LDA, DOVEADM, uwezekano wa mchakato wa IMAP, nk Watumiaji ambao wana
  # ruhusa kamili kwa tundu hili zina uwezo wa kupata orodha ya majina yote ya watumiaji na
  # Pata matokeo ya lookups za kila mtu za mtumiaji.
  #
  # Njia ya chaguo -msingi 0666 inaruhusu mtu yeyote kuungana na tundu, lakini
  # USERDB Lookups zitafanikiwa tu ikiwa UserDB itarudisha uwanja wa "UID" hiyo
  # inalingana na UID ya mchakato wa mpigaji. Pia ikiwa UID ya mpigaji au GID inalingana
  # Socket's UID au GID Lookup inafanikiwa. Kitu kingine chochote husababisha kutofaulu.
  #
  # Kumpa mpigaji ruhusa kamili ili kuangalia watumiaji wote, weka hali hiyo
  # kitu kingine kuliko 0666 na Dovecot inaruhusu kernel kutekeleza
  # Ruhusa (k.m. 0777 inaruhusu kila mtu ruhusa kamili).
  unix_listener/var/spool/postfix/private/mwandishi {
    mode = 0660
    Mtumiaji = Postfix
    kikundi = postfix
  }
}

Mfanyakazi-Mfanyakazi wa Huduma {
  # Mchakato wa mfanyakazi wa mwandishi unaendeshwa kama mzizi kwa chaguo -msingi, ili iweze kupata
  # /nk /kivuli. Ikiwa hii sio lazima, mtumiaji anapaswa kubadilishwa kuwa
  # $ default_internal_user.
  #user = mzizi
}

DICT ya huduma {
  # Ikiwa proksi ya DICT inatumika, michakato ya barua inapaswa kupata tundu lake.
  # Kwa mfano: mode = 0660, kikundi = Vmail na mail_access_groups = vmail
  unix_listener dict {
    #mode = 0600
    #user = 
    #group = 
  }
}
# default_process_limit = 100
# default_client_limit = 1000
# Kikomo cha VSZ (saizi ya kumbukumbu halisi) Kikomo cha michakato ya huduma. Hii ni hasa
# ilikusudia kukamata na kuua michakato ambayo huvuja kumbukumbu kabla ya kula
# kila kitu.
# default_vsz_limit = 256m
# Mtumiaji wa kuingia hutumiwa ndani na michakato ya kuingia. Hii ndio isiyoaminika zaidi
# Mtumiaji katika mfumo wa dovecot. Haipaswi kupata kitu chochote kabisa.
# default_login_user = dovenull
# Mtumiaji wa ndani hutumiwa na michakato isiyo na usalama. Inapaswa kutengwa na
# Mtumiaji wa kuingia, ili michakato ya kuingia haiwezi kuvuruga michakato mingine.
# default_internal_user = dovecot
# bandari = 143
# bandari = 993
# SSL = ndio
# Idadi ya miunganisho ya kushughulikia kabla ya kuanza mchakato mpya. Kawaida
# Thamani muhimu tu ni 0 (isiyo na kikomo) au 1. 1 ni salama zaidi, lakini 0
# ni haraka. <doc/wiki/loginprocess.txt>
# HUDUMA_COUNT = 1
# Idadi ya michakato ya kuendelea kungojea miunganisho zaidi.
# process_min_avail = 0
# Ikiwa utaweka huduma_count = 0, labda unahitaji kukuza hii.
# vsz_limit = $ default_vsz_limit
# bandari = 110
# bandari = 995
# SSL = ndio
# bandari = 587
# Unda msikilizaji wa inet tu ikiwa huwezi kutumia tundu la hapo juu la UNIX
# inet_listener lmtp {
# Epuka kufanya LMTP ionekane kwa mtandao mzima
# Anwani =
bandari =

}

Kumbukumbu nyingi huenda kwa faili za MMAP (). Unaweza kuhitaji kuongeza hii

Punguza ikiwa una sanduku kubwa za barua.

vsz_limit = $ default_vsz_limit

Max. Idadi ya michakato ya IMAP (viunganisho)

process_limit = 1024

Max. Idadi ya michakato ya POP3 (viunganisho)

process_limit = 1024

Max. Idadi ya michakato ya uwasilishaji wa SMTP (viunganisho)

process_limit = 1024

AUTH_SOCKET_PATH inaelekeza kwenye tundu hili la UserDB kwa chaguo -msingi. Ni kawaida

Kutumiwa na dovecot-lda, doveadm, uwezekano wa mchakato wa IMAP, nk Watumiaji ambao wana

Ruhusa kamili kwenye tundu hili zina uwezo wa kupata orodha ya majina yote ya watumiaji na

Pata matokeo ya lookups za kila mtu za mtumiaji.

Njia chaguo -msingi 0666 inaruhusu mtu yeyote kuungana na tundu, lakini
# Utumiaji wa USERDB utafaulu tu ikiwa UserDB itarudisha uwanja wa "UID" hiyo
# inalingana na UID ya mchakato wa mpigaji. Pia ikiwa UID ya mpigaji au GID inalingana
# UID ya Socket au GID Lookup inafanikiwa. Kitu kingine chochote husababisha kutofaulu.
# 
# Ili kumpa mpigaji ruhusa kamili ili kuangalia watumiaji wote, weka hali hiyo
# Kitu kingine kuliko 0666 na Dovecot inaruhusu kernel kutekeleza
# Ruhusa (k.m. 0777 inaruhusu kila mtu ruhusa kamili).
# Mchakato wa mfanyakazi wa mwandishi unaendeshwa kama mzizi kwa chaguo -msingi, ili iweze kupata
# /nk/kivuli. Ikiwa hii sio lazima, mtumiaji anapaswa kubadilishwa kuwa
# $ default_internal_user.
# mtumiaji = mzizi
# Ikiwa wakala wa DICT hutumiwa, michakato ya barua inapaswa kupata tundu lake.
# Kwa mfano: mode = 0660, kikundi = Vmail na mail_access_groups = vmail
# mode = 0600
# mtumiaji =
# kikundi =
# Kwa mara nyingine tena, hakikisha kuchukua nafasi ya kikoa katika faili hizi zote, femmebabe.com, na kikoa ulichochagua. Hariri faili inayofuata, usanidi wa dovecot,
# nano config/nk_dovecot_dovecot
# Na ongeza mistari hii
# ## Faili ya usanidi wa Dovecot

# Ikiwa uko haraka, angalia http://wiki2.dovecot.org/quickconfiguration

# "DoveConf -N" amri inatoa pato safi la mipangilio iliyobadilishwa. Tumia
# badala ya kunakili na kubandika; faili wakati wa kutuma kwenye orodha ya barua ya Dovecot.

Tabia ya# '#' na kila kitu baada ya kutibiwa kama maoni. Nafasi za ziada
# na tabo hupuuzwa. Ikiwa unataka kutumia yoyote ya haya wazi, weka
# Thamani ya Ndani ya Nukuu, Mfano: Ufunguo = "# Char na Trailing Whitespace"

# Mipangilio mingi (lakini sio yote) inaweza kupitishwa na itifaki tofauti na/au
# Chanzo/IPS ya Marudio kwa kuweka mipangilio ndani ya sehemu, kwa mfano:
# Itifaki imap {}, mitaa 127.0.0.1 {}, mbali 10.0.0.0/8 {}

# Thamani za chaguo -msingi zinaonyeshwa kwa kila mpangilio, haihitajiki kutengwa
# hizo. Hizi ni ubaguzi kwa hii ingawa: hakuna sehemu (k.m. Namespace {})
# au mipangilio ya programu -jalizi huongezwa na chaguo -msingi, imeorodheshwa tu kama mifano.
Njia # pia ni mifano tu na defaults halisi kuwa msingi wa usanidi
Chaguzi #. Njia zilizoorodheshwa hapa ni za usanidi -prefix =/usr
# - -sysconfdir =/nk - -localstatedir =/var

# Wezesha itifaki zilizowekwa
! ni pamoja na_try /usr/share/dovecot/protocols.d/*.protocol

# Orodha iliyotengwa ya IPs au majeshi mahali pa kusikiliza kwa miunganisho. 
# "*" husikiza katika miingiliano yote ya IPv4, "::" husikiliza katika miingiliano yote ya IPv6.
# Ikiwa unataka kutaja bandari zisizo za default au kitu chochote ngumu zaidi,
# hariri conf.d/master.conf.
#listen = *, ::

# Saraka ya msingi ambapo kuhifadhi data ya wakati wa kukimbia.
#base_dir =/var/run/dovecot/

# Jina la mfano huu. Katika usanidi wa muundo wa aina nyingi na amri zingine
# inaweza kutumia -i kuchagua ni mfano gani unaotumika (mbadala
# to -c). Jina la mfano pia linaongezwa kwa michakato ya dovecot
# katika pato la PS.
#instance_name = dovecot

# Ujumbe wa salamu kwa wateja.
#login_greeting = dovecot tayari.

# Nafasi iliyotengwa orodha ya safu za mtandao zinazoaminika. Miunganisho kutoka kwa hizi
# IPS inaruhusiwa kupitisha anwani zao za IP na bandari (kwa ukataji miti na
# Kwa ukaguzi wa uthibitishaji). Lemaza_Plaintext_Auth pia hupuuzwa
# Mitandao hii. Kawaida utaelezea seva zako za wakala wa IMAP hapa.
#login_trust_networks =

# Orodha iliyotengwa ya nafasi ya soketi za ufikiaji wa kuingia (k.m. TCPWrap)
#login_access_sockets = 

# Na proxy_maybe = ndio ikiwa marudio ya wakala yanafanana na yoyote ya IPs hizi, usifanye
# kueneza. Hii sio lazima kawaida, lakini inaweza kuwa muhimu ikiwa marudio
# IP ni n.k. IP ya balancer ya mzigo.
#auth_proxy_self =

# Onyesha majina zaidi ya mchakato wa kitenzi (katika PS). Hivi sasa inaonyesha jina la mtumiaji na
# Anwani ya IP. Muhimu kwa kuona ni nani anayetumia michakato ya IMAP
# (kwa mfano. Sanduku za barua zilizoshirikiwa au ikiwa UID sawa inatumika kwa akaunti nyingi).
#verbose_proctitle = hapana

# Je! Michakato yote inauawa wakati mchakato wa Dovecot unafunga.
# Kuweka hii kwa "hapana" inamaanisha kuwa dovecot inaweza kuboreshwa bila
# kulazimisha miunganisho ya mteja iliyopo kufunga (ingawa hiyo inaweza pia kuwa
# Shida ikiwa sasisho ni n.k. Kwa sababu ya kurekebisha usalama).
#shutdown_clients = ndio

# Ikiwa sio Zero, endesha amri za barua kupitia miunganisho hii mingi kwa seva ya Doveadm,
# badala ya kuziendesha moja kwa moja katika mchakato huo huo.
#doveadm_worker_count = 0
# Socket ya Unix au mwenyeji: bandari inayotumika kwa kuunganisha kwa seva ya DoveADM
#doveadm_socket_path = doveadm-seva

# Orodha iliyotengwa ya nafasi za mazingira ambazo zimehifadhiwa kwenye dovecot
# Kuanza na kupitishwa kwa michakato yake yote ya mtoto. Unaweza pia kutoa
# ufunguo = jozi za thamani ili kuweka mipangilio maalum kila wakati.
#import_en mazingira = tz

##
Mipangilio ya seva ya##
##

# Kamusi inaweza kutumika kuhifadhi ufunguo = orodha za thamani. Hii hutumiwa na kadhaa
# plugins. Kamusi inaweza kupatikana ama moja kwa moja au ingawa a
# seva ya kamusi. Vifungu vifuatavyo vya kuzuia ramani za kamusi kwa URIs
# Wakati seva inatumiwa. Hizi zinaweza kurejelewa kwa kutumia URIS katika muundo
# "Wakala ::".

Dict {
  #quota = mysql: /etc/dovecot/dovecot-dict-sql.conf.ext
}

# Usanidi halisi hujumuishwa hapa chini. Majina ya faili ni
# Kwanza ilipangwa na thamani yao ya ASCII na iliyowekwa katika mpangilio huo. 00-prefixes
# Katika majina ya faili yamekusudiwa kuifanya iwe rahisi kuelewa kuagiza.
! Jumuisha conf.d/*. Conf

# Faili ya usanidi pia inaweza kujaribu kujumuishwa bila kutoa kosa ikiwa
# haipatikani:
! ni pamoja na_try local.conf

passdb {
  Dereva = faili ya kupita
  args =/nk/dovecot/passwd
}
USERDB {
  Dereva = Passwd
}

Itifaki = imap pop3

#Allows dovecot kusikiliza miunganisho yote ya pembejeo (IPv4 / IPv6)

sikiliza = *, ::
Faili ya Usanidi wa Dovecot

Ikiwa uko haraka, angalia http://wiki2.dovecot.org/quickconfiguration

Amri ya "DoveConf -N" inatoa pato safi la mipangilio iliyobadilishwa. Tumia
ping femmebabe.com # Badala ya nakala na faili za kubandika wakati wa kutuma kwenye orodha ya barua ya Dovecot.
'Tabia na kila kitu baada ya kutibiwa kama maoni. Nafasi za ziada

na tabo hupuuzwa. Ikiwa unataka kutumia yoyote ya haya wazi, weka

Char na Trailing Whitespace "

Mipangilio mingi (lakini sio yote) inaweza kupitishwa na itifaki tofauti na/au

Chanzo/marudio IPs kwa kuweka mipangilio ndani ya sehemu, kwa mfano:

Itifaki imap {}, mitaa 127.0.0.1 {}, mbali 10.0.0.0/8 {}

Thamani za chaguo -msingi zinaonyeshwa kwa kila mpangilio, haihitajiki kutengwa
sudo certbot --apache --non-interactive --agree-tos --domains <domain>.com --email <youremail>@gmail.com
wale. Hizi ni ubaguzi kwa hii ingawa: hakuna sehemu (k.m. Namespace {})

Au mipangilio ya programu -jalizi huongezwa kwa chaguo -msingi, imeorodheshwa kama mifano tu.

Njia pia ni mifano tu na defaults halisi kuwa msingi wa usanidi
nano yourproject/settings.py
Chaguzi. Njia zilizoorodheshwa hapa ni za usanidi -prefix =/usr

--sysconfdir =/nk--localstatedir =/var

Wezesha itifaki zilizowekwa
# Orodha iliyotengwa ya IPS au majeshi mahali pa kusikiliza kwa miunganisho.
"

Ikiwa unataka kutaja bandari zisizo za default au kitu chochote ngumu zaidi,

Hariri conf.d/master.conf.
sudo nano /etc/apache2/sites-available/femmebabe-le-ssl.conf
sikiliza = *, ::

Saraka ya msingi ambapo kuhifadhi data ya wakati wa kukimbia.

base_dir =/var/run/dovecot/
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>
Jina la mfano huu. Katika usanidi wa muundo wa aina nyingi na amri zingine

Je! Unaweza kutumia -i <ambolence_name> kuchagua ni mfano gani unaotumika (mbadala

kwa -C <Config_Path>). Jina la mfano pia linaongezwa kwa michakato ya dovecot
sudo a2dissite 000-default-le-ssl
sudo a2dissite 000-default
sudo a2dissite default-ssl
katika pato la PS.

mfano_name = dovecot

Ujumbe wa salamu kwa wateja.
sudo a2ensite femmebabe-le-ssl
sudo systemctl reload apache2
Ingia_greeting = Dovecot tayari.

Nafasi iliyotengwa orodha ya safu za mtandao zinazoaminika. Miunganisho kutoka kwa hizi

IPS inaruhusiwa kuzidi anwani zao za IP na bandari (kwa ukataji miti na
cd projectname
source venv/bin/activate
python manage.py check
Kwa ukaguzi wa uthibitishaji). Lemaza_Plaintext_Auth pia hupuuzwa

Mitandao hii. Kawaida utaelezea seva zako za wakala wa IMAP hapa.

Ingia_trust_networks =
nano venv/lib/python3.12/site-packages/django/apps/registry.py
Orodha iliyotengwa ya nafasi ya soketi za ufikiaji wa kuingia (k.m. tcpwrap)

Ingia_access_sockets =

Na proxy_maybe = ndio ikiwa marudio ya wakala yanafanana na yoyote ya IPs hizi, usifanye
                # Kuongeza. Hii sio lazima kawaida, lakini inaweza kuwa muhimu ikiwa marudio
                # IP ni n.k. IP ya balancer ya mzigo.
# AUTH_PROXY_SELSE =
Onyesha majina zaidi ya mchakato wa kitenzi (katika PS). Hivi sasa inaonyesha jina la mtumiaji na

Anwani ya IP. Muhimu kwa kuona ni nani anayetumia michakato ya IMAP

(mfano. sanduku za barua zilizoshirikiwa au ikiwa UID sawa inatumika kwa akaunti nyingi).
python manage.py check
Verbose_proctitle = hapana

Je! Michakato yote ingeuawa wakati mchakato wa Dovecot unafunga.

Kuweka hii kwa "hapana" inamaanisha kuwa dovecot inaweza kuboreshwa bila
                # kulazimisha miunganisho ya mteja iliyopo kufunga (ingawa hiyo inaweza pia kuwa
                # Shida ikiwa sasisho ni n.k. Kwa sababu ya kurekebisha usalama).
# shutdown_clients = ndio
Ikiwa sio Zero, endesha amri za barua kupitia miunganisho hii mingi kwa seva ya Doveadm,

Badala ya kuziendesha moja kwa moja katika mchakato huo huo.

DOVEADM_WORKER_COUNT = 0
sudo systemctl reload apache2
Socket ya UNIX au mwenyeji: bandari inayotumika kwa kuunganisha na seva ya Doveadm

DOVEADM_SOCKET_PATH = DOVEADM-SERVER

Orodha iliyotengwa ya nafasi za anuwai za mazingira ambazo zimehifadhiwa kwenye dovecot

Kuanza na kupitishwa kwa michakato yake yote ya mtoto. Unaweza pia kutoa

ufunguo = jozi za thamani ili kuweka mipangilio maalum kila wakati.

kuagiza_ni mazingira = tz

ip -6 addr
Mipangilio ya Seva ya Kamusi

Kamusi inaweza kutumika kuhifadhi ufunguo = orodha za thamani. Hii hutumiwa na kadhaa

programu -jalizi. Kamusi inaweza kupatikana ama moja kwa moja au ingawa a

seva ya kamusi. Vifungu vifuatavyo vya kuzuia ramani za kamusi kwa URIs

Wakati seva inatumiwa. Hizi zinaweza kurejelewa kwa kutumia URIS katika muundo

"Wakala :: <name>".

Quota = mysql: /etc/dovecot/dovecot-dict-sql.conf.ext

Usanidi mwingi halisi unajumuishwa hapa chini. Majina ya faili ni

Kwanza imepangwa na thamani yao ya ASCII na iliyowekwa katika mpangilio huo. 00-prefixes

Katika majina ya faili yamekusudiwa kuifanya iwe rahisi kuelewa kuagiza.

Faili ya usanidi pia inaweza kujaribu kujumuishwa bila kutoa kosa ikiwa

Haipatikani:

Inaruhusu DoveCot kusikiliza miunganisho yote ya pembejeo (IPv4 / IPv6)

Ongeza nywila kwa mtumiaji wa dovecot:

nano config/nk_dovecot_passwd

Sehemu ya kwanza ya faili, kabla ya koloni, ni jina la mtumiaji. Sehemu ya mwisho, "YourPassword", inaashiria nywila ambayo ungependa kutoa seva yako ya barua.

Timu: {wazi} neno lako

Ifuatayo, usanidi wa Opendkim
nano config/etc_postfix_main.cf
Nano Config/nk_opendkim.conf

Na ongeza mistari hii:

# Hii ni usanidi wa msingi wa kusaini na kuthibitisha. Inaweza kuwa kwa urahisi # Imechukuliwa ili kuendana na usanikishaji wa kimsingi. Tazama Opendkim.conf (5) na # /usr/share/doc/opendkim/examples/opendkim.conf.sampuli kamili # Nyaraka za vigezo vya usanidi vinavyopatikana. Syslog ndio Syslogsuccess ndio #Logwhy hapana # Viwango vya kawaida vya kusaini na uthibitisho. Katika Debian, kichwa cha "kutoka" ni # Imechangiwa, kwa sababu mara nyingi ni ufunguo wa kitambulisho unaotumiwa na mifumo ya sifa # na kwa hivyo usalama fulani nyeti. Canonicalization iliyorejeshwa/rahisi Mode s Vidokezo hapana Oversignheaders kutoka # Kusaini kikoa, kuchagua, na ufunguo (inahitajika). Kwa mfano, fanya kusaini # kwa kikoa "mfano.com" na Selector "2020" (2020._domainkey.ex samp.com), # Kutumia kitufe cha kibinafsi kilichohifadhiwa katika /etc/dkimkeys/ex samp.private. Granular zaidi Chaguzi # za usanidi zinaweza kupatikana katika /usr/share/doc/opendkim/readme.opendkim. #Domain mfano.com #Selector 2020 #Keyfile /etc/dkimkeys/ex samp.private # Katika Debian, Opendkim anaendesha kama mtumiaji "Opendkim". Umask ya 007 inahitajika wakati # Kutumia tundu la ndani na MTAs ambazo zinapata tundu kama isiyo na upendeleo # Mtumiaji (kwa mfano, postfix). Unaweza kuhitaji kuongeza "postfix" ya mtumiaji kwa kikundi # "Opendkim" katika kesi hiyo. USERID OPENDKIM Umask 007 # Soketi ya unganisho la MTA (inahitajika). Ikiwa MTA iko ndani ya gereza la Chroot, # Lazima ihakikishwe kuwa tundu linapatikana. Katika Debian, Postfix inaingia # chroot in/var/spool/postfix, kwa hivyo tundu la unix lingehitajika kuwa # Imesanidiwa kama inavyoonyeshwa kwenye mstari wa mwisho hapa chini. #Socket ya ndani: /run/opendkim/opendkim.sock #Socket Inet: 8891@localhost #Socket Inet: 8891 Socket ya ndani: /var/spool/postfix/opendkim/opendkim.sock Pidfile /run/opendkim/opendkim.pid # Majeshi ambayo kusaini badala ya kuthibitisha, chaguo -msingi ni 127.0.0.1. Tazama # Sehemu ya operesheni ya Opendkim (8) kwa habari zaidi. #InternalHosts 192.168.0.0/16, 10.0.0.0/8, 172.16.0.0/12 # Anchor ya uaminifu inawezesha DNSSEC. Katika Debian, faili ya nanga ya uaminifu hutolewa # na kifurushi cha DNS-mizizi-data. Trustanchorfile /usr/share/dns/root.key #Nameservers 127.0.0.1 # Vikoa vya ramani kutoka kwa anwani hadi funguo zinazotumiwa kusaini ujumbe Kifunguo kinachoweza kufikiwa: /etc/opendkim/key.table Kusaini kwa kusainiwa: /etc/opendkim/signing.table # Seti ya majeshi ya ndani ambayo barua yake inapaswa kusainiwa NdaniHosts /etc/opendkim/trust.hosts
# Hii ni usanidi wa kimsingi wa kusaini na kuthibitisha. Inaweza kuwa kwa urahisi
# Imechukuliwa ili kuendana na usanikishaji wa kimsingi. Tazama Opendkim.conf (5) na
# /usr/share/doc/opendkim/examples/opendkim.conf.sampuli kamili
# Nyaraka za vigezo vya usanidi vinavyopatikana.
# Logwhy hapana
# Viwango vya kawaida vya kusaini na uthibitisho. Katika Debian, kichwa cha "kutoka" ni
# Imechangiwa, kwa sababu mara nyingi ni ufunguo wa kitambulisho unaotumiwa na mifumo ya sifa
# na kwa hivyo usalama fulani nyeti.
# Kusaini kikoa, kuchagua, na ufunguo (inahitajika). Kwa mfano, fanya kusaini
# Kwa kikoa "mfano.com" na Selector "2020" (2020._domainkey.ex samp.com),
# Kutumia kitufe cha kibinafsi kilichohifadhiwa katika /etc/dkimkeys/ex samp.private. Granular zaidi
# Chaguzi za usanidi zinaweza kupatikana katika /usr/share/doc/opendkim/readme.opendkim.
Mfano wa kikoa.com

Chaguzi 2020

Keyfile /etc/dkimkeys/ex samp.private
nano config/etc_postfix_master.cf
Katika Debian, Opendkim anaendesha kama mtumiaji "Opendkim". Umask ya 007 inahitajika wakati

Kutumia tundu la ndani na MTAs ambazo zinapata tundu kama isiyo na upendeleo

Mtumiaji (kwa mfano, postfix). Unaweza kuhitaji kuongeza "postfix" ya mtumiaji kwa kikundi
# "Opendkim" katika kesi hiyo.
# Tundu la unganisho la MTA (inahitajika). Ikiwa MTA iko ndani ya gereza la Chroot,
# lazima ihakikishwe kuwa tundu linapatikana. Katika Debian, Postfix inaingia
# Chroot in/var/spool/postfix, kwa hivyo tundu la UNIX lingekuwa
# Imesanidiwa kama inavyoonyeshwa kwenye mstari wa mwisho hapa chini.
# Socket ya ndani: /run/opendkim/opendkim.sock
# Socket Inet: 8891@localhost
# Socket Inet: 8891
# Majeshi ambayo kusaini badala ya kuthibitisha, chaguo -msingi ni 127.0.0.1. Tazama
# Sehemu ya operesheni ya Opendkim (8) kwa habari zaidi.
# Internative 192.168.0.0/16, 10.0.0.0/8, 172.16.0.0/12
# Anchor ya uaminifu inawezesha DNSSEC. Katika Debian, faili ya nanga ya uaminifu hutolewa
# na kifurushi cha DNS-mizizi-data.
# Nameservers 127.0.0.1
# Vikoa vya ramani kutoka kwa anwani hadi funguo zinazotumiwa kusaini ujumbe
# Seti ya majeshi ya ndani ambayo barua yake inapaswa kusainiwa
# nano config/nk_default_opendkim
# Na ongeza mistari hii
# # Kumbuka: Hii ni faili ya usanidi wa urithi. Haitumiwi na Opendkim
Huduma # ya mfumo. Tafadhali tumia vigezo vya usanidi vinavyoendana
# /etc/opendkim.conf badala yake.
#
# Hapo awali, mtu angebadilisha mipangilio ya chaguo -msingi hapa, na kisha kutekeleza
# /lib/opendkim/opendkim.service.generate ili kutoa faili zilizozidi za mfumo
# /etc/systemd/system/opendkim.service.d/override.conf na
# /etc/tmpfiles.d/opendkim.conf. Wakati hii bado inawezekana, ni sasa
# Ilipendekezwa kurekebisha mipangilio moja kwa moja katika /etc/opendkim.conf.
#
#Daemon_opts = ""
# Badilisha kwa/var/spool/postfix/run/opendkim kutumia tundu la UNIX na
# postfix kwenye chroot:
#Rundir =/var/spool/postfix/run/opendkim
Rundir =/Run/OpenDKim
#
# Uncomment kutaja tundu mbadala
# Kumbuka kuwa kuweka hii itaongeza thamani yoyote ya tundu katika OpendKim.conf
# chaguo -msingi:
Socket = "Mitaa: /var/spool/postfix/opendkim/opendkim.sock"
# Sikiza kwenye miingiliano yote kwenye bandari 54321:
#Socket = Inet: 54321
# sikiliza juu ya Loopback kwenye bandari 12345:
#Socket = Inet: 12345@localhost
# Sikiza mnamo 192.0.2.1 kwenye bandari 12345:
#Socket = inet: 12345@192.0.2.1
Mtumiaji = OpenDKim
Kikundi = OpendKim
Pidfile = $ rundir/$ name.pid
Zaidi ya ziada =
# Kumbuka: Hii ni faili ya usanidi wa urithi. Haitumiwi na Opendkim
# huduma ya mfumo. Tafadhali tumia vigezo vya usanidi vinavyoendana
# /etc/opendkim.conf badala yake.
# 
# Hapo awali, mtu angebadilisha mipangilio ya chaguo -msingi hapa, na kisha kutekeleza
# /lib/opendkim/opendkim.service.generate ili kutoa faili zilizozidi za mfumo
# /etc/systemd/system/opendkim.service.d/override.conf na
# /etc/tmpfiles.d/opendkim.conf. Wakati hii bado inawezekana, ni sasa
# ilipendekezwa kurekebisha mipangilio moja kwa moja katika /etc/opendkim.conf.
# 
# Daemon_opts = ""
# Badilisha kwa/var/spool/postfix/run/opendkim kutumia tundu la UNIX na
# Postfix katika Chroot:
# Rundir =/var/spool/postfix/run/opendkim
# 
# Uncomment kutaja tundu mbadala
# Kumbuka kuwa kuweka hii itaongeza thamani yoyote ya tundu katika OpendKim.conf
# Chaguo -msingi:
# Sikiza kwenye miingiliano yote kwenye bandari 54321:
# Socket = inet: 54321
# Sikiza juu ya Loopback kwenye bandari 12345:
# Socket = inet: 12345@localhost
# Sikiza mnamo 192.0.2.1 kwenye bandari 12345:
# Socket = inet: 12345@192.0.2.1
# Tunapokuwa tayari kuanzisha seva yetu ya PostFix, tutaendesha nambari iliyo chini, na jina linalofaa la kikoa lililoingia. Anza kwa kuunda hati
# Gusa hati/postfixSetup
sudo chmod a+x script/postfixSetup
Nano Hati/PostFixSetup
# Sasa, katika Nano, mhariri wa maandishi, hariri faili hii kwa hivyo inajumuisha jina lako la kikoa badala ya femmebabe.com.
# #!/bin/bash
# Usanidi wa posta
CD $ dir
echo "usanidi wa huduma za barua"
sudo cp /etc/postfix/main.cf /etc/postfix/main.cf.backup
Sudo CP Config/nk_postfix_main.cf /etc/postfix/main.cf
Sudo CP Config/nk_postfix_master.cf /etc/postfix/master.cf
Sudo CP Config/nk_default_opendkim/nk/default/opendkim
Sudo CP Config/nk_dovecot_conf.d_10-auth.conf /etc/dovecot/conf.d/10-auth.conf
Sudo CP Config/nk_dovecot_conf.d_10-master.conf /etc/dovecot/conf.d/10-master.conf
Sudo CP Config/nk_dovecot_dovecot.conf /etc/dovecot/dovecot.conf
Sudo CP Config/nk_dovecot_passwd/nk/dovecot/passwd
Sudo CP Config/nk_opendkim.conf /etc/opendkim.conf
Sudo CP Config/nk_default_opendkim/nk/default/opendkim
Sudo AddUser Postfix Opendkim
sudo mkdir /nk /opendkim
sudo mkdir/nk/opendkim/funguo
sudo mkdir /etc/opendkim/keys/femmebabe.com
sudo mkdir/var/spool/postfix/opendkim
sudo echo "*@femmebabe.com sendenly._domainkey.femmebabe.com" | sudo tee -a /etc/opendkim/signing.table
sudo echo "sendenly._domainkey.femmebabe.com femmebabe.com:sendonly:/etc/opendkim/keys/femmebabe.com/sendonly.private" | sudo tee -a /etc/opendkim/key.table
Sudo echo "127.0.0.1" | sudo tee -a /etc/opendkim/trust.hosts
sudo echo "localhost" | sudo tee -a /etc/opendkim/trust.hosts
sudo echo "" | sudo tee -a /etc/opendkim/trust.hosts
sudo echo "*.femmebabe.com" | sudo tee -a /etc/opendkim/trust.hosts
Sudo Chown -r OpendKim: Opendkim /nk /Opendkim
sudo Opendkim-Genkey -B 2048 -d femmebabe.com -d /etc/opendkim/keys/femmebabe.com -s sendenly -v
sudo chmod go-rw/nk/opendkim/funguo
Sudo Chown Opendkim: Opendkim /etc/opendkim/keys/femmebabe.com/sendonly.private
Sudo Chown Opendkim: Postfix/var/spool/postfix/Opendkim
CD $ dir
sanduku la barua la sudo cp/*/var/mail/
Sudo Chown: watumiaji/var/mail/*
sudo chmod -r a+rwx/var/mail/*
Sudo Systemctl Anzisha tena Opendkim Postfix Dovecot
sudo paka /etc/opendkim/keys/femmebabe.com/sendonly.txt | tr -d '\ n' | sed 's/\ s // g' | sed 's/"" // g' | awk -f '[) (]' '{chapisha $ 2}'
# !/bin/bash
# Sanidi Postfix
# Sasa, endesha hati iliyokamilishwa kusanidi Postfix, Opendkim na Dovecot.
# ./Scripts/PostFixSetup
# Mara tu hati hii ikiwa inaendelea, nakili mstari wa mwisho unachapisha na kuiweka kwenye usanidi wako wa DNS kama thamani ya sendenly._domainkey. Hii ndio kitufe cha Opendkim kinachotumiwa kutambua kikoa chako wakati wa kutuma barua salama.
# Ya kushangaza! Ndani ya siku chache, unapaswa kutuma barua kutoka kwa seva iliyotolewa kila kitu kimeundwa kwa usahihi.
# Ikiwa umesanidi tu DNS kwa seva yako ya barua, inapaswa kuchukua chini ya masaa 72 kwa rekodi kusasisha. Kawaida ni haraka sana. Unaweza kuangalia ikiwa seva yako inafanya kazi kwa kutumia amri hii, imetoa barua pepe yako:
# echo "mtihani" | Barua -S "Barua pepe ya Jaribio" youremail@gmail.com
# Ikiwa kila kitu kinaonekana kufanya kazi kwa usahihi, unapaswa kuwa na uwezo wa kutuma barua pepe na seva yako. Ikiwa haifanyi kazi, jaribu kuangalia magogo ili kuona kosa linaweza kuwa nini.
# Mkia -Lines 150 /var/log/mail.log
# Hii itatoa habari ya kitenzi kuhusu barua ambayo inatumwa na seva na ikiwa inafanya kazi vizuri. Unapaswa kuwa na uwezo wa kuona barua pepe kwenye kikasha chako pia, ikiwa haipo, angalia folda yako ya spam.
# Utahitaji pia kusanidi mipangilio yako katika mipangilio yako.py ili seva yako ya barua pepe iweze kuzungumza na programu yako ya Django, mradi huo. Ongeza au ubadilishe mistari hii kwenye mipangilio yako
# Barua pepe_host = kikoa
Barua pepe_port = 587
Barua pepe_use_tls = kweli
Barua pepe_address = 'team@femmebabe.com'
Barua pepe_host_user = 'timu' #'love@mamasheen.com '
Barua pepe_host_password = usanidi ['barua pepe_host_password']
Default_from_email = '{} <{}>'. Fomati (tovuti_name, barua pepe_host_user)
# 'Love@mamasheen.com'
# Tambua kuwa tunatumia faili ya usanidi kupata nywila. Wacha tupakie faili hii kwenye mipangilio kama hivyo, mwanzoni mwa faili.:
# kuagiza OS
kuagiza JSON

# Fungua na upakia usanidi
na wazi ('/nk/config.json') kama config_file:
    Config = json.load (Config_File)
# Fungua na upakia usanidi
# Wacha tuunda faili hii na kuongeza kitufe cha siri kwake, pamoja na nywila ya barua. Ili kutoa ufunguo wa siri, tumia amri hii, na urefu wowote unaopenda mwisho:
# OpenSSL RAND -BASE64 64
# Sasa, nakili maandishi ambayo yanafungua na hariri /etc/config.json
# Sudo Nano /etc/config.json
# Ongeza mistari ifuatayo kwenye faili yako, na ufunguo ambao OpenSSL inayozalishwa kama ufunguo wa siri.
# {
	"Siri_key": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	"Barua pepe_host_password": "YourPassword"
}
# Fomati ya JSON ni rahisi na rahisi kutumia, tunaweza kutangaza funguo zingine ambazo tunataka kutumia katika mradi wetu kwa njia hii pia, na kuziweka tofauti na saraka yetu ya mradi ili watumiaji wengine hawawezi kuwaandikia na kwa hivyo hawawezi kusomwa kutoka saraka yetu ya mradi pekee. Hii inapendekezwa mazoezi kwa funguo za API, ambazo tutatumia zaidi ya wachache hapa.
# Pia utataka kuunga mkono mradi wako ili kuhakikisha kuwa kila kitu kimeokolewa na utaweza kupata kazi yako baadaye hata ikiwa hautaki tena kukodisha seva.
# Backup ya Sudo
# Sasa, jaribu kutuma barua pepe ya HTML kutoka kwa seva ya wavuti, mradi tu kupeleka moja kutoka kwa mstari wa amri unafanya kazi. Hoja mfano wako wa mtumiaji kwenye ganda, na tuma barua pepe ya HTML kwa mtumiaji huyo kupitia Django. Badilisha jina langu katika nambari, Charlotte, kwa jina lako la mtumiaji.
# Python kusimamia.py ganda
kutoka django.contrib.auth.Models Mtumiaji wa kuagiza
u = mtumiaji.objects.get (jina la mtumiaji = 'charlotte')
kutoka kwa watumiaji.Email kuagiza send_welcome_email
send_welcome_email (u)
Utgång()
# Ikiwa amri ya kwanza haifanyi kazi, hakikisha kutumia
# Chanzo Venv/bin/actishate
# Isipokuwa kila kitu kimewekwa kwa usahihi, sasa utapata barua pepe ya kuwakaribisha kwenye sanduku lako la barua lililotumwa na programu yako ya wavuti. Kazi nzuri! Umekuja mbali.
# Nilitaka kuongeza, ikiwa unapambana na makosa yoyote wakati wa kufanya kazi kwenye mradi kama huu, usisite kutafuta majibu na uombe msaada. Google, kati ya injini zingine za utaftaji, ni rasilimali kubwa kutafuta msaada wa programu. Tafuta tu kosa unalopata, na utaweza kuona jinsi watu wengine wanavyotatua shida. Pia, unakaribishwa kuwasiliana nami, waelimishaji wako (waalimu, maprofesa, wakufunzi), wenzi wowote kwenye mtandao ambao wanapatikana kwa msaada wa programu, au wasiliana na kitabu hiki tena au rasilimali zingine kupata suluhisho la maswala unayopitia. Ninaelewa hii sio rahisi, lakini hata ikiwa umesoma hivi sasa na haukuandika nambari yoyote, unajifunza mengi juu ya kujenga programu ya wavuti kutoka mwanzo. Jipatie mgongoni, unafanya kazi nzuri.
# Asante kwa kuchukua wakati wa kusoma Mwongozo huu wa Maendeleo ya Wavuti ya Toleo la Tatu. Katika matoleo yajayo, nitajumuisha mifano zaidi muhimu iliyojadiliwa mwanzoni mwa hati na tutaingia zaidi katika ulimwengu wa programu na maendeleo ya vifaa. Kaa tuned kwa kile kinachokuja, na ninatarajia kukufundisha jinsi ya kujenga programu ya ajabu. Tutaonana katika toleo linalofuata!
# Tembelea kiunga hiki (itakuchukua nje ya Lotte Harper)








nano config/etc_default_opendkim
























nano config/etc_dovecot_conf.d_10-master.conf
































































nano config/etc_dovecot_dovecot











































































nano config/etc_dovecot_passwd

team:{plain}yourpassword

nano config/etc_opendkim.conf


































nano config/etc_default_opendkim
























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


./scripts/postfixsetup

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

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

openssl rand -base64 64

sudo nano /etc/config.json

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

sudo backup

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

source venv/bin/activate






దగ్గరగా
పేజీ 1
జంప్
పూర్తి వ్యాసం చూడండి
చదవడం కొనసాగించండి

క్రిప్టోతో కొనండి



https://glamgirlx.com/te/practical-web-based-deep-learning-and -


ప్రొఫెషనల్ ఎంటర్టైన్మెంట్, ఫోటోలు, వీడియోలు, ఆడియో, లైవ్‌స్ట్రీమింగ్ మరియు సాధారణం గేమ్‌ప్లే, అలాగే ఐడి స్కానింగ్, వెబ్ డెవలప్‌మెంట్ మరియు సర్రోగసీ సేవలు.

ఈ చిరునామాను ఉపయోగించి బిట్‌కాయిన్‌లో నాకు చిట్కా వదిలేయండి: 3KhDWoSve2N627RiW8grj6XrsoPT7d6qyE

© Glam Girl X 2025

సేవా నిబంధనలు