Hoe de Django-beheerinterface inschakelen en verbinden

Introductie

Als je de Django-ontwikkelingsserie hebt gevolgd, ben je begonnen met een Django-toepassing, heb je je toepassing verbonden met MySQL en de database-modellen aangemaakt voor de Posts en Comments gegevens binnen je blog webtoepassing.

In deze tutorial zullen we verbinding maken met en de Django-beheersite inschakelen, zodat je je blogwebsite kunt beheren. De Django-beheersite wordt standaard geleverd met een gebruikersinterface die is ontworpen om jou en andere vertrouwde personen in staat te stellen de inhoud van de website te beheren.

Het is vermeldenswaard dat de officiële documentatie van Django erop wijst dat hoewel dit ideaal is voor intern gebruik van een organisatie, het niet wordt aanbevolen om een webtoepassing te bouwen rond een automatisch gegenereerde Django-beheerinterface. Als je merkt dat je interface meer procesgericht moet zijn of blijkt dat deze de implementatiedetails van database-tabellen en -velden abstract maakt, is het het beste om je eigen weergaven voor de beheerkant te schrijven.

Vereisten

Deze tutorial maakt deel uit van de Django-ontwikkelingsserie en is een voortzetting van die serie.

Als je niet hebt meegedaan met deze serie, gaan we ervan uit dat:

• Je Django versie 4 of hoger geïnstalleerd hebt.
• Je je Django-applicatie hebt verbonden met een database. We gebruiken MySQL, en je kunt deze verbinding tot stand brengen door deel twee van de Django-serie te volgen, genaamd “Hoe maak je een Django-app en verbind je deze met een database.”
• Je werkt met een op Unix gebaseerd besturingssysteem, bij voorkeur een Ubuntu 22.04-cloudserver, aangezien dit het systeem is waarop we hebben getest. Als je Django op een vergelijkbare omgeving wilt instellen, raadpleeg dan onze tutorial, “Hoe Django te installeren en een ontwikkelomgeving op te zetten op Ubuntu 22.04.”

Aangezien deze tutorial voornamelijk gaat over de Django-beheerinterface, kun je mogelijk meedoen, zelfs als je een enigszins andere opstelling hebt.

Stap 1 — Schakel de beheerinterface in

Wanneer we beginnen te werken in Python en Django, moeten we onze Python virtuele omgeving activeren en naar de hoofdmap van onze app gaan. Als je de serie hebt gevolgd, kun je dit bereiken door het volgende in te typen.

cd ~/my_blog_app
. env/bin/activate

Om de Django Admin in te schakelen, moeten we ervoor zorgen dat onze app deel uitmaakt van de lijst met INSTALLED_APPS in het settings.py bestand.

Navigeer naar de map van het instellingenbestand:

cd ~/my_blog_app/blog/blog/

Vanaf hier, open het settings.py bestand. Als het er nog niet is, voeg django.contrib.admin toe aan de lijst met INSTALLED_APPS, met behulp van een teksteditor zoals nano.

nano settings.py

Het gedeelte INSTALLED_APPS van het bestand moet vergelijkbaar zijn met het onderstaande bestand. Onze app in de lijst is degene bovenaan, 'blogsite', maar als je een app met een andere naam hebt gemaakt, zorg er dan voor dat die app in dit bestand wordt vermeld zoals gedemonstreerd.

...
# Applicatiedefinitie
INSTALLED_APPS = [
    'blogsite',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]
...

Zorg ervoor dat je het bestand opslaat en sluit als je wijzigingen hebt aangebracht. In nano kun je dit doen door CTRL en X in te typen, dan Y en vervolgens ENTER.

We kunnen nu het urls.py bestand openen, opnieuw met nano of een andere teksteditor.

nano urls.py

Onder de opmerking bovenaan moet het bestand lijken op het volgende.

…
"""
from django.contrib import admin
from django.urls import path

urlpatterns = [
    path('admin/', admin.site.urls),
]

Als het bestand verschilt van wat hierboven staat, kopieer en plak dan de bovenstaande regels in je urls.py bestand.

Nu we ervoor hebben gezorgd dat ons Django-webproject de juiste code heeft in de settings.py– en urls.py-bestanden, weten we dat onze applicatie toegang zal hebben tot de beheermodellen en de beheergebruikersinterface.

Stap 2 — Controleer of Admin een Geïnstalleerde Applicatie is

Vervolgens moeten we de modellen migreren naar de database, zodat deze de nieuw toegevoegde beheermodellen oppikt.

Navigeer naar de map waar het manage.py-bestand zich bevindt.

cd ~/my_blog_app/blog

Vergeet niet om het migrate-commando uit te voeren telkens wanneer u wijzigingen aanbrengt in de modellen, zoals dit.

python manage.py migrate

Als we geen wijzigingen hebben aangebracht in de bovenstaande bestanden, zouden we bij het uitvoeren van het migrate-commando een uitvoer moeten ontvangen die vergelijkbaar is met het volgende.

Output
Operations to perform:
  Apply all migrations: admin, auth, blogsite, contenttypes, sessions
Running migrations:
  No migrations to apply.

Anders zou de uitvoer moeten aangeven dat Django de migraties heeft gemaakt die nodig zijn om onze app te ondersteunen.

We kunnen nu de server starten door het volgende commando uit te voeren. U kunt 0.0.0.0 vervangen door uw IP-adres.

python manage.py runserver 0.0.0.0:8000

Navigeer vervolgens naar de URL van het beheerpaneel in een browser naar keuze. Zorg ervoor dat u het IP-adres van uw server invoert.

http://your-server-ip:8000/admin/

U ontvangt een inlogscherm dat vergelijkbaar is met dit.

Als we dit scherm bereiken, weten we dat we de beheer-app succesvol hebben ingeschakeld.

Hoewel we de app hebben ingeschakeld, hebben we mogelijk nog geen Django-beheeraccount ingesteld. We kunnen het beheeraccount aanmaken om vervolgens in te loggen in de volgende stap.

Stap 3 — Maak een beheer-supergebruikersaccount aan

Als u al een beheeraccount heeft ingesteld en kunt inloggen op uw beheerpagina, kunt u deze stap overslaan.

Open een nieuwe terminal om verbinding te maken met de server, of schakel de Django-app uit door op CTRL en C te drukken, zodat we kunnen werken in de programmeeromgeving van onze serverterminal.

Django biedt de mogelijkheid om een supergebruikersaccount te genereren, wat we kunnen doen door het manage.py-bestand uit te voeren om het proces voor het maken van de supergebruiker te starten.

python manage.py createsuperuser

Zodra we dit doen, worden we gevraagd om details in te vullen voor onze gebruikersnaam, e-mail en wachtwoord. In deze handleiding maken we een beheeraccount met de gebruikersnaam admin_user, de e-mail [email protected] en het wachtwoord admin123. U moet deze informatie invullen met uw eigen voorkeuren en ervoor zorgen dat u een veilig wachtwoord gebruikt dat u zult onthouden.

Output
Username (leave blank to use 'root'): admin_user
Email address: [email protected]

Vervolgens voert u uw wachtwoord twee keer in wanneer u het Wachtwoord:-prompt ziet. U ontvangt geen uitvoer van de toetsaanslagen van uw wachtwoord wanneer u het invoert. Druk na elke prompt op enter om uw wachtwoord te bevestigen.

Output
Password:
Password (again):

Op dit punt hebben we nu een beheerdersaccount met de gebruikersnaam admin_user en het wachtwoord admin123.

Laten we inloggen en onderzoeken wat er op onze beheerderspagina staat.

Indien nodig, voer de Django-app opnieuw uit met python manage.py runserver 0.0.0.0:8000 en ga vervolgens nogmaals naar de URL http://your-server-ip:8000/admin/ om naar de inlogpagina van de beheerder te gaan. Log dan in met de gebruikersnaam en het wachtwoord dat je zojuist hebt aangemaakt.

Na succesvol inloggen ontvang je de volgende pagina.

Vervolgens moeten we werken aan het verbinden van onze blog-app met het beheerderspaneel.

Stap 4 — Maak URL-patronen voor Post en Reactie

In de vorige stap zijn we succesvol ingelogd op de beheerdersinterface, maar je hebt misschien gemerkt dat onze blog-app daar nog niet beschikbaar is. Om onze beheerdersinterface te vullen met de blog-app, moeten we deze toevoegen en registreren bij de bijbehorende modellen Post en Comment.

Om dit te doen, zullen we een leeg bestand genaamd urls.py aanmaken, in de blogsite map, als volgt:

touch ~/my_blog_app/blog/blogsite/urls.py

In dit bestand zullen we het URL-patroon voor onze blogtoepassing toevoegen, zodat we er via de beheerdersinterface toegang toe kunnen krijgen.

Navigeer naar de locatie van dat zojuist aangemaakte urls.py bestand.

cd ~/my_blog_app/blog/blogsite/

Dan open je het bestand met nano, bijvoorbeeld.

nano urls.py

Voeg de volgende regels code toe aan het bestand.

from django.urls import path
from . import views
urlpatterns = [
    path('$/', views.posts, name='posts'),
    path('$/', views.comments, name='comments'),
]

Dit zijn de URL-patroonuitdrukkingen die nodig zijn om onze applicatie toegang te geven tot de views voor Posts en Comments. We hebben deze views nog niet gemaakt, maar dat behandelen we later in de serie.

Stap 5 — Verbind de Blog App met Admin

Door onze blog te verbinden met het beheerdersinterface kunnen we links zien voor zowel de Posts als Comments in het beheerdersdashboard. Op dit moment worden er alleen links weergegeven voor Groups en Users in het dashboard.

Om ze met elkaar te verbinden, moeten we onze modellen Posts en Comments registreren in het admin-bestand van blogsite.

Navigeer naar de blogsite-directory:

cd ~/my_blog_app/blog/blogsite

Open vervolgens het bestand admin.py in een teksteditor naar keuze.

nano admin.py

Het bestand zal gevuld zijn met een importverklaring en een opmerking.

from django.contrib import admin

# Registreer hier je modellen.

Bewerk het bestand zodat het de volgende code bevat om onze app te ondersteunen.

from django.contrib import admin
from blogsite.models import Post
from blogsite.models import Comment


admin.site.register(Post)
admin.site.register(Comment)

Als je tevreden bent met het bestand, sla het dan op en sluit het af.

Je hebt nu de modellen Post en Comment geregistreerd binnen het beheerderspaneel. Hierdoor kan het beheerdersinterface deze modellen oppikken en aan de gebruiker laten zien die is ingelogd en het beheerdersdashboard bekijkt.

Stap 6 — Verifieer dat de Blog App aan het Admin is toegevoegd

Nu je de relevante Python-code hebt toegevoegd, start je de server. Open http://your-server-ip:8000/admin en log in op het beheerdersaccount met je referenties als je nog niet bent ingelogd. In deze handleiding hebben we ingelogd met de gebruikersnaam admin_user en het wachtwoord admin123.

Nu je bent ingelogd, zou je de volgende webpagina moeten zien. Als deze niet is veranderd ten opzichte van eerder, moet je mogelijk je browser vernieuwen.

Dit bevestigt dat we nu onze app, blogsite, hebben verbonden met het Django-beheerdersdashboard.

Als je klaar bent met het testen van je app, kun je op CTRL + C drukken om de Django-server te stoppen. Hiermee keer je terug naar je programmeeromgeving.

Wanneer je klaar bent om je Python-omgeving te verlaten, kun je het deactivate-commando uitvoeren:

deactivate

Door je programmeeromgeving te deactiveren, kom je terug bij de opdrachtprompt van de terminal.

Conclusie

In deze tutorial heb je met succes de beheerinterface ingeschakeld, een beheerderslogin aangemaakt en de modellen Post en Comment geregistreerd bij de beheerdersinterface.

De Django-beheerinterface is hoe je berichten kunt maken en opmerkingen kunt controleren met je blog.

Volgende keer in de serie zullen we de views voor de blogtoepassing maken.