---
title: "Så här installerar du Django"
version: 6.0
locale: sv
source: https://docs.djangoproject.com/sv/6.0/topics/install/
canonical: https://djangodocs.dev/sv/6.0/topics/install/
---
# Så här installerar du Django

Detta dokument hjälper dig att komma igång med Django.

## Installera Python

Django är ett webbramverk i Python. Se [Vilken Python-version kan jag använda med Django?](/sv/6.0/faq/install/#faq-python-version-support) för mer information.

Hämta den senaste versionen av Python på <https://www.python.org/downloads/> eller med ditt operativsystems pakethanterare.

> **Python på Windows**
>
> Om du precis har börjat med Django och använder Windows, kanske du tycker att [Så här installerar du Django på Windows](/sv/6.0/howto/windows/) är användbart.

## Installera Apache och `mod_wsgi`

Om du bara vill experimentera med Django kan du hoppa vidare till nästa avsnitt; Django innehåller en lättviktig webbserver som du kan använda för testning, så du behöver inte installera Apache förrän du är redo att distribuera Django i produktion.

Om du vill använda Django på en produktionssite ska du använda [Apache](https://httpd.apache.org/) med [mod\_wsgi](https://modwsgi.readthedocs.io/en/develop/). mod\_wsgi fungerar i ett av två lägen: inbäddat läge eller daemonläge. I inbäddat läge liknar mod\_wsgi mod\_perl - det bäddar in Python i Apache och laddar Python-kod i minnet när servern startar. Koden stannar i minnet under hela Apache-processens livstid, vilket leder till betydande prestandavinster jämfört med andra serverarrangemang. I daemonläge skapar mod\_wsgi en oberoende daemonprocess som hanterar förfrågningar. Daemonprocessen kan köras som en annan användare än webbservern, vilket eventuellt kan leda till förbättrad säkerhet. Daemonprocessen kan startas om utan att hela Apache-webbservern startas om, vilket kan göra uppdateringen av din kodbas mer sömlös. Se dokumentationen för mod\_wsgi för att avgöra vilket läge som är rätt för din installation. Se till att du har Apache installerat med mod\_wsgi-modulen aktiverad. Django kommer att fungera med alla versioner av Apache som stöder mod\_wsgi.

Se [Hur man använder Django med mod\_wsgi](/sv/6.0/howto/deployment/wsgi/modwsgi/) för information om hur man konfigurerar mod\_wsgi när man har installerat det.

Om du av någon anledning inte kan använda mod\_wsgi, var inte orolig: Django stöder många andra distributionsalternativ. Ett är [uWSGI](/sv/6.0/howto/deployment/wsgi/uwsgi/); det fungerar mycket bra med [nginx](https://nginx.org/). Dessutom följer Django WSGI-specifikationen ([**PEP 3333**](https://peps.python.org/pep-3333/)), vilket gör att den kan köras på en mängd olika serverplattformar.

## Få igång din databas

Om du planerar att använda Djangos databas-API-funktionalitet måste du se till att en databasserver körs. Django stöder många olika databasserver och stöds officiellt med [PostgreSQL](https://www.postgresql.org/), [MariaDB](https://mariadb.org/), [MySQL](https://www.mysql.com/), [Oracle](https://www.oracle.com/) och [SQLite](https://www.sqlite.org/).

Om du utvecklar ett litet projekt eller något som du inte planerar att distribuera i en produktionsmiljö är SQLite i allmänhet det bästa alternativet eftersom det inte kräver att du kör en separat server. SQLite har dock många skillnader jämfört med andra databaser, så om du arbetar med något stort rekommenderar vi att du utvecklar med samma databas som du planerar att använda i produktionen.

Utöver de databaser som stöds officiellt finns det [backends som tillhandahålls av tredje part](/sv/6.0/ref/databases/#third-party-notes) som gör att du kan använda andra databaser med Django.

Om du vill använda en annan databas än SQLite måste du se till att lämpliga Python-databasbindningar är installerade:

- Om du använder PostgreSQL behöver du paketet [psycopg](https://www.psycopg.org/psycopg3/) eller [psycopg2](https://www.psycopg.org/). Se [PostgreSQL notes](/sv/6.0/ref/databases/#postgresql-notes) för ytterligare information.
- Om du använder MySQL eller MariaDB behöver du en [DB API-drivrutin](/sv/6.0/ref/databases/#mysql-db-api-drivers) som `mysqlclient`. Se [notes for the MySQL backend](/sv/6.0/ref/databases/#mysql-notes) för mer information.
- Om du använder SQLite kanske du vill läsa [SQLite backend notes](/sv/6.0/ref/databases/#sqlite-notes).
- Om du använder Oracle måste du installera [oracledb](https://oracle.github.io/python-oracledb/), men läs [notes for the Oracle backend](/sv/6.0/ref/databases/#oracle-notes) för information om vilka versioner av både Oracle och `oracledb` som stöds.
- Om du använder en inofficiell backend från tredje part, se den dokumentation som tillhandahålls för eventuella ytterligare krav.

Och se till att följande nycklar i `'default'` i [`DATABASES`](/sv/6.0/ref/settings/#std-setting-DATABASES)-ordlistan stämmer överens med dina inställningar för databasanslutning:

- [`ENGINE`](/sv/6.0/ref/settings/#std-setting-DATABASE-ENGINE) – Antingen `'django.db.backends.sqlite3'`, `'django.db.backends.postgresql'`, `'django.db.backends.mysql'`, eller `'django.db.backends.oracle'`. Andra backends är [också tillgängliga](/sv/6.0/ref/databases/#third-party-notes).
- [`NAME`](/sv/6.0/ref/settings/#std-setting-NAME) – Namnet på din databas. Om du använder SQLite kommer databasen att vara en fil på din dator. I så fall ska `NAME` vara den fullständiga absoluta sökvägen, inklusive filnamnet på den filen. Du behöver inte skapa något i förväg, utan databasfilen skapas automatiskt när den behövs. Standardvärdet, `BASE_DIR / 'db.sqlite3'`, lagrar filen i din projektkatalog.

> **För andra databaser än SQLite**
>
> Om du inte använder SQLite som databas måste du lägga till ytterligare inställningar, t.ex. [`USER`](/sv/6.0/ref/settings/#std-setting-USER), [`PASSWORD`](/sv/6.0/ref/settings/#std-setting-PASSWORD) och [`HOST`](/sv/6.0/ref/settings/#std-setting-HOST). Mer information finns i referensdokumentationen för [`DATABASES`](/sv/6.0/ref/settings/#std-setting-DATABASES).
>
> Se också till att du har skapat databasen vid det här laget. Gör det med ”`CREATE DATABASE database_name;`” i databasens interaktiva prompt.

Om du planerar att använda Djangos kommando `manage.py migrate` för att automatiskt skapa databastabeller för dina modeller (efter att du först har installerat Django och skapat ett projekt), måste du se till att Django har behörighet att skapa och ändra tabeller i den databas du använder; om du planerar att manuellt skapa tabellerna kan du ge Django behörigheterna `SELECT`, `INSERT`, `UPDATE` och `DELETE`. När du har skapat en databasanvändare med dessa behörigheter anger du detaljerna i ditt projekts inställningsfil, se `DATABASER` för detaljer.

Om du använder Djangos [testramverk](/sv/6.0/topics/testing/) för att testa databasfrågor, behöver Django tillstånd att skapa en testdatabas.

## Installera Django-koden

Installationsanvisningarna skiljer sig något åt beroende på om du installerar ett distributionsspecifikt paket, hämtar den senaste officiella versionen eller hämtar den senaste utvecklingsversionen.

### Installera en officiell version med `pip`

Detta är det rekommenderade sättet att installera Django.

1. Installera [pip](https://pip.pypa.io/). Det enklaste är att använda det fristående installationsprogrammet för [pip](https://pip.pypa.io/). Om din distribution redan har `pip` installerat, kan du behöva uppdatera det om det är föråldrat. Om det är föråldrat vet du det eftersom installationen inte fungerar.
2. Ta en titt på [venv](https://docs.python.org/3/tutorial/venv.html). Detta verktyg tillhandahåller isolerade Python-miljöer, vilket är mer praktiskt än att installera paket i hela systemet. Det gör det också möjligt att installera paket utan administratörsbehörighet. I [contributing tutorial](/sv/6.0/intro/contributing/) går man igenom hur man skapar en virtuell miljö.
3. När du har skapat och aktiverat en virtuell miljö skriver du in kommandot:

   ```console
   $ python -m pip install Django
   ```

   *Windows*

   ```doscon
   ...\> py -m pip install Django
   ```

### Installera ett distributionsspecifikt paket

Kontrollera [distributionsspecifika anmärkningar](/sv/6.0/misc/distributions/) för att se om din plattform/distribution tillhandahåller officiella Django-paket/installerare. Paket som tillhandahålls av distributionen tillåter vanligtvis automatisk installation av beroenden och uppgraderingsvägar som stöds; dessa paket innehåller dock sällan den senaste versionen av Django.

### Installera utvecklingsversionen

> **Spårning av Django-utveckling**
>
> Om du bestämmer dig för att använda den senaste utvecklingsversionen av Django, bör du vara mycket uppmärksam på [utvecklingstidslinjen](https://code.djangoproject.com/timeline) och hålla ett öga på [versionsinformation för den kommande utgåvan](/sv/6.0/releases/#development-release-notes). Detta hjälper dig att hålla dig uppdaterad om nya funktioner som du kanske vill använda, samt eventuella ändringar som du behöver göra i din kod när du uppdaterar din kopia av Django. (För stabila utgåvor dokumenteras alla nödvändiga ändringar i versionsinformation)

Om du vill kunna uppdatera din Django-kod då och då med de senaste buggfixarna och förbättringarna, följ dessa instruktioner:

1. Se till att du har [Git](https://git-scm.com/) installerat och att du kan köra dess kommandon från ett skal. (Ange `git help` vid en shell-prompt för att testa detta)
2. Kolla in Djangos huvudsakliga utvecklingsgren på följande sätt:

   ```console
   $ git clone https://github.com/django/django.git
   ```

   *Windows*

   ```doscon
   ...\> git clone https://github.com/django/django.git
   ```

   Detta kommer att skapa en katalog `django` i din nuvarande katalog.
3. Se till att Python-tolken kan ladda Djangos kod. Det mest praktiska sättet att göra detta är att använda en virtuell miljö och [pip](https://pip.pypa.io/). I [Bidragshandledning](/sv/6.0/intro/contributing/) går vi igenom hur man skapar en virtuell miljö.
4. När du har konfigurerat och aktiverat den virtuella miljön kör du följande kommando:

   ```console
   $ python -m pip install -e django/
   ```

   *Windows*

   ```doscon
   ...\> py -m pip install -e django\
   ```

   Detta kommer att göra Djangos kod importerbar och kommer också att göra kommandot `django-admin` tillgängligt. Med andra ord, du är redo!

När du vill uppdatera din kopia av Djangos källkod kör du kommandot `git pull` från katalogen `django`. När du gör detta kommer Git att ladda ner alla ändringar.
