[ad_1]
On this tutorial, we’ll have a look at what static information are in Django, the advantages of managing them effectively, their objective in internet functions, and we’ll arrange a demo challenge as an instance methods to handle and serve static information utilizing completely different strategies and instruments.
Desk of Contents
Django is a high-level Python internet improvement framework that gives internet builders with a strong toolkit to create internet functions shortly and effectively.
Whereas Django is nice for creating internet functions shortly and effectively, it’s equally necessary to maintain the appear and feel of the net functions you develop. In an effort to do this, you could have learn to handle the property that help and supply the appear and feel of your functions.
Static Recordsdata in Django
In Django, static information are these information which are served on to the shopper with none processing by the server.
These usually embrace CSS, JavaScript information, pictures, icons, fonts and different property essential for the appear and feel of your internet software.
Django offers mechanisms to handle and serve these static information effectively, making certain a easy person expertise.
Managing static information effectively
To make sure that the customers of your internet software have person expertise and the appliance performs as anticipated, you need to handle the static information effectively.
Correctly organizing and caching static information will guarantee quick web page load occasions, and that responsiveness is improved, enhancing general person satisfaction.
Django affords varied instruments and conventions to help within the dealing with of static information.
The aim of static information in internet functions
Static information are essential, as they set out how an internet software appears and feels. They outline how elements in an software are styled, how they behave in response to person interactions, and ultimately what a person sees once they go to a selected internet software.
Whenever you serve the static information effectively, you’ll have the ability to create a visually interesting and responsive person interface, making the appliance extra participating and person pleasant.
Setting Up a Demo Mission
As an instance the ideas of static information administration in Django, we’ll arrange a demo challenge from scratch.
This challenge will embrace making a Django challenge, configuring static file settings, and integrating static information right into a easy internet software.
By following together with the demo challenge, you’ll acquire hands-on expertise with managing static information in Django and perceive their significance in internet improvement.
For the needs of this tutorial, we are going to create a touchdown web page such that when customers go to the house web page of our challenge, they’ll see a styled heading welcoming them to the location. It should additionally show as we speak’s date utilizing JavaScript, and we may also serve a picture to finish the web page.
Making a listing to carry the challenge
Let’s start by making a listing that may maintain the demo challenge utilizing the next command:
mkdir sitepoint_django_static_tut
Making a digital surroundings
It’s really useful that you just create and isolate new tasks inside digital environments. Because of this every challenge could have its personal dependencies with out affecting the worldwide Python set up.
We’ll use the virtualenv bundle to create it. If it isn’t put in in your improvement surroundings, set up it utilizing pip set up virtualenv, and create a digital surroundings utilizing the next command:
virtualenv myenv
The above command creates a digital surroundings named myenv. To make use of the digital surroundings, you need to activate it:
Linux/macOS:
. myenv/bin/activate
Home windows:
. myenvScriptsactivate
Putting in dependencies
As soon as the digital surroundings is energetic, now you can go forward and set up the dependencies of your challenge. For a begin, we’ll set up Django. We’ll set up different dependencies as we get to the sections that reveal their utilization:
pip set up Django
This may set up the most recent steady model of Django, which on the time of writing is model 5.0.
Making a Django challenge
Upon profitable set up of Django, you now have entry to Django administration instructions. Let’s use them to create a Django challenge within the digital surroundings:
django-admin startproject sitepoint_django .
The command above will create Django challenge named sitepoint_django and the dot on the finish signifies that we intend to create the challenge within the present listing.
Making a demo app
As an instance the assorted ideas of the static file administration, we have to create at the least one Django app in our challenge:
python handle.py startapp static_demo
This may create a brand new app in our challenge named static_demo. For it to be acknowledged by our challenge, we’ve got so as to add it to the put in apps setting within the settings.py file of our challenge. Open up sitepoint_django/settings.py, go to the INSTALLED_APPS setting and add static_demo.apps.StaticDemoConfig to the underside of the listing, as proven under:
INSTALLED_APPS = [
‘static_demo.apps.StaticDemoConfig’,
]
Creating the house web page template
We’ll render some HTML when the person visits the house web page of our web site. Within the static_demo app, create a templates listing, and in it create one other listing and identify it static_demo. On this listing, create a template and identify it index.html so the trail will likely be static_demo/templates/static_demo/index.html.
Place the next code into index.html:
<!DOCTYPE html>
<html lang=”en”>
<head>
<meta charset=”UTF-8″>
<meta identify=”viewport” content material=”width=device-width, initial-scale=1.0″>
<title>Sitepoint Django Tutorial</title>
</head>
<physique>
<h2>Hiya there, welcome to our nice web site!</h2>
</physique>
</html>
Creating the index view
For the template to be proven to customers each time they go to the house web page of our app, we have to create a view operate that will likely be triggered to render the house.html template. Open the static_demo/views.py file and put within the following code:
from django.shortcuts import render
def index(request):
return render(request, “static_demo/house.html”)
Creating the static_demo URL file
We would like the index view within the static_demo app to render the house web page each time a person visits our web site. So we’ll create a URL scheme for the view operate that may render the house web page. For that, we have to create a urls.py file for the static_demo app, then join the static_demo URL file to tasks URL file.
Due to this fact, within the static_demo app, create a file and identify it urls.py and add the next code into it:
from django.urls import path
from .import views
app_name = ‘static_demo’
urlpatterns = [
path(”, views.index, name=”index”),
]
The code above creates a URL for the index view of our challenge, so if a person visits one thing like http://oursite.com/, or for those who go to http://127.0.0.1:8000 in improvement, the index view will likely be referred to as to answer that.
Let’s add it to the challenge URL file. Open up the sitepoint_django/urls.py file and add within the following code:
from django.contrib import admin
from django.urls import path, embrace
urlpatterns = [
path(‘admin/’, admin.site.urls),
path(”, include(‘static_demo.urls’)),
]
The code above makes some adjustments to the default urls.py file. We’ve added an import for embrace operate, which tells Django that we’re together with the static_demo.urls.
Testing the challenge
The preliminary configuration of the challenge is completed at this level. Let’s run the event server to see if every thing is tied up effectively.
Run the challenge with the next command:
python handle.py runserver
If every thing is setup accurately, you must have the ability to go to http://127.0.0.1:8000. You’ll see some unstyled textual content welcoming you to the location.
Serving Static Recordsdata in Growth
In an effort to add styling to the web page, JavaScript for the date, and the picture, we’ve got to make adjustments to the challenge. Let’s accomplish that incrementally and see how we are able to serve the completely different static information in several methods, beginning with the event surroundings.
Organising a static information listing
Django recommends that every one static property be managed appwise: that’s, all CSS, JS and pictures {that a} specific app wants must be resident within the confines of that app. So let’s replace the static_demo app and create a listing named static, and inside it create one other listing named static_demo. Then within the static_demo listing create three extra directories: css, js, and pictures. Ultimately, we’ll have a construction much like the one under:
static_demo/
└── static/
└── static_demo/
├── css/
├── js/
└── pictures/
The rationale why you’ll need to create a static_demo listing within the static listing is that can assist you namespace your static property. When you’ve got a couple of app, and you’ve got the CSS in each apps named as kinds.css, Django would solely work with the primary stylesheet it finds, because it wouldn’t have the ability to distinguish between the others. Due to this fact, we namespace them in order that Django will have the ability to know which asset file we’re referring to in our templates.
Creating the static information
On this step, let’s simply arrange minimal static property that may reveal how one can serve the information in improvement.
Within the js listing, create a file and identify it todays_date.js, and add the next code:
let formattedDate = new Date().toLocaleDateString();
doc.getElementById(‘todaysDate’).innerText = `The date as we speak is ${formattedDate}`;
The code above will get as we speak’s date from JavaScript, codecs it right into a string, after which shows it in a div with an ID of todaysDate.
Within the css listing, create a file, identify it kinds.css, and add the next code:
physique {
show: flex;
flex-direction: column;
justify-content: middle;
align-items: middle;
margin: 0;
}
h2 {
font-size: 24px;
colour: inexperienced;
}
The code above makes use of the Flexbox format to middle all of the objects on the web page each horizontally and vertically. It additionally units the H2 aspect’s font measurement to 24px and its colour to inexperienced.
For the picture, you need to use any picture of your liking. Simply copy some picture into the photographs listing and pay attention to the identify.
Configuring static file settings
To serve static information in improvement, quite a few issues should be set within the Django settings.py file. Open the sitepoint_django/settings.py file and verify to see it you could have the next settings:
DEBUG=True
In improvement, it’s usually really useful to set DEBUG to True in your Django challenge settings. This setting allows varied debugging options, together with detailed error messages and stack traces, that are invaluable for diagnosing and fixing points throughout improvement.
Moreover, when DEBUG is about to True, the django.contrib.staticfiles app routinely serves static information from every app’s static listing. This conduct simplifies the event course of by eliminating the necessity for handbook configuration to serve static information.
Within the INSTALLED_APPS setting, verify to see in case you have the django.contrib.staticfiles added. If not, add it above the apps you could have within the challenge. For instance, on this challenge add it above the static_demo app string, as proven under:
INSTALLED_APPS = [
‘django.contrib.staticfiles’,
‘static_demo.apps.StaticDemoConfig’,
]
The django.contrib.staticfiles app supplied by Django is crucial for serving static information throughout improvement. By default, it traverses your challenge’s apps to find static file directories inside every app. Nonetheless, in case you have further static property that aren’t related to any specific app, you possibly can nonetheless make them accessible to django.contrib.staticfiles by setting the STATICFILES_DIRS setting in your challenge’s settings.py file. This setting permits you to specify further directories the place static information are positioned. For instance:
STATICFILES_DIRS = [
“/dir/with/staticfiles/static”,
“/someother/dir/static”,
“/home/example.com/static”,
]
Along with DEBUG and STATICFILES_DIRS, one other necessary setting to incorporate in your Django challenge settings file is STATIC_URL. Whereas Django offers a default worth for STATIC_URL, you possibly can explicitly outline it in your settings.py file if it’s not already current.
The STATIC_URL setting specifies the bottom URL from which static property will likely be served. For instance, setting STATIC_URL = “static/” instructs Django to serve static property from the /static/ URL path. Because of this, as an example, the kinds file positioned within the static_demo app will likely be accessible at a URL like http://127.0.0.1:8000/static/static_demo/css/kinds.css.
Updating the template
With the settings out of the best way, to make use of the static information within the template, we’ve got to replace it with the next HTML:
{% load static %}
<!DOCTYPE html>
<html lang=”en”>
<head>
<meta charset=”UTF-8″>
<meta identify=”viewport” content material=”width=device-width, initial-scale=1.0″>
<title>Sitepoint Django Tutorial</title>
<hyperlink rel=”stylesheet” href=”{% static ‘static_demo/css/kinds.css’%}”>
</head>
<physique>
<h2>Hiya there, welcome to our nice web site</h2>
<p id=”todaysDate”></p>
<img src=”{% static ‘static_demo/pictures/flowerImage.png’ %}” alt=”Flower Picture”>
<script src=”{% static ‘static_demo/js/todays_date.js’ %}”></script>
</physique>
</html>
That template replace introduces us to a brand new tag: {% load static %}. This tag masses the static file dealing with performance supplied by the Django templating engine. Together with this tag in a Django template file allows us to make use of template tags and filters associated to static information.
For instance, utilizing it in our template allows us to reference static information like pictures, CSS and JS in HTML parts. Utilizing it additionally allows Django to generate URLs for the references static property:
<hyperlink rel=”stylesheet” href=”{% static ‘static_demo/css/kinds.css’%}”>
<img src=”{% static ‘static_demo/pictures/flowerImage.png’ %}” alt=”Flower Picture”>
<script src=”{% static ‘static_demo/js/todays_date.js’ %}”></script>
With these settings and the template replace in place, we must always run the challenge and see if the information are being served in improvement. Run the challenge utilizing the next command:
python handle.py runserver
If every thing is about up accurately, we must always have the event server working on http://127.0.0.1:8000. If we go to that hyperlink, we must always have web page much like the one under.
Having an analogous picture reveals that the static information have been utilized accurately.
You need to notice that in Django improvement, when DEBUG=True in your challenge’s settings, and django.contrib.staticfiles is enabled, this enables Django’s improvement server (runserver) to serve static information. On this state of affairs, any adjustments made to static information, equivalent to CSS, JavaScript, or pictures, are routinely detected and utilized by Django. This seamless course of enormously simplifies improvement, as you’ll immediately see the results of your adjustments without having to manually refresh or restart the server.
Nonetheless, in manufacturing environments, serving static information usually entails utilizing a separate internet server or CDN. On this case, adjustments to static information will not be routinely detected and utilized by Django, necessitating handbook intervention to make sure that the up to date information are served to customers. Moreover, for those who decide to manually serve static information utilizing a unique technique, such because the django.views.static.serve() view, automated detection and software of adjustments could not happen, and you could must implement your individual mechanisms for dealing with static file updates.
Serving Static Recordsdata Utilizing WhiteNoise
In improvement, whereas django.contrib.staticfiles simplifies the method of serving static property, making certain seamless updates as you make adjustments.
Nonetheless, when transitioning to manufacturing, settings like DEBUG=True should be disabled, and static information could be served from a CDN or one other server. This necessitates an answer that bridges each environments — enabling easy serving of information throughout improvement whereas precisely reflecting the manufacturing surroundings.
Enter the WhiteNoise bundle. Designed to seamlessly combine with Django, WhiteNoise affords a sturdy answer for serving static information in each improvement and manufacturing environments, offering a unified strategy that ensures consistency and reliability throughout deployment phases. Let’s discover WhiteNoise.
Putting in and configuring WhiteNoise in Django
Getting began with WhiteNoise is simple .On this part, we’ll stroll by means of the set up course of and information you on methods to configure WhiteNoise inside your Django challenge.
We set up WhiteNoise like so:
pip set up whitenoise
After profitable set up, head over to sitepoint_django/settings.py, scroll right down to the underside, and discover the STATIC_URL setting. Under it, add the STATIC_ROOT setting:
STATIC_ROOT = BASEDIR / “staticfiles”
The setting above tells Django that when the collectstatic is run all static property in all apps in your challenge will likely be collected and saved into this listing named staticfiles.
The following factor to do is to run the collectstatic administration command:
python handle.py collectstatic
To allow WhiteNoise, you need to add it to the MIDDLEWARE settings listing, edit the settings.py file, and add the WhiteNoise middleware after the Django SecurityMiddleware and earlier than all different middleware:
MIDDLEWARE = [
“django.middleware.security.SecurityMiddleware”,
“whitenoise.middleware.WhiteNoiseMiddleware”,
]
Utilizing WhiteNoise in improvement
With simply the steps above, WhiteNoise can serve you static information in manufacturing. However for those who run the challenge at this level, the Django improvement server will routinely take over static file dealing with. However to profit from related conduct in improvement and in manufacturing, it’s a good suggestion to make use of it serve information in improvement as effectively.
To try this, we’ll disable Django’s static file dealing with and permit WhiteNoise to take over by merely modifying the settings file and including the WhiteNoise to INSTALLED_APPS listing setting above the django.contrib.staticfiles:
INSTALLED_APPS = [
“whitenoise.runserver_nostatic”,
“django.contrib.staticfiles”,
]
You additionally must disable DEBUG by setting it to False:
DEBUG=False
With these steps, you possibly can seamlessly serve your static property utilizing the WhiteNoise bundle.
To confirm that WhiteNoise is certainly serving your information, you possibly can take away or remark out the django.contrib.staticfiles choice from the INSTALLED_APPS setting listing. Nonetheless, it’s necessary to notice that eradicating django.contrib.staticfiles will render a couple of static file administration instructions unavailable, such because the collectstatic command. This command is crucial for accumulating and consolidating static information out of your apps right into a single listing for environment friendly serving in manufacturing environments.
Superior WhiteNoise configuration choices
Whereas the steps above are enough for many circumstances, WhiteNoise offers a couple of extra choices for configuration. For instance, you possibly can add compression and caching help to your challenge. To allow it, open the sitepoint_django/settings.py file and add the next settings:
STORAGES = {
“staticfiles”: {
“BACKEND”: “whitenoise.storage.CompressedManifestStaticFilesStorage”,
},
}
The setting above will be sure that WhiteNoise compresses and hashes the static information to distinctive identify, so they are going to be safely cached.
Utilizing WhiteNoise in shared internet hosting environments
Shared internet hosting is a kind of hosting service the place a number of web sites are hosted on a single bodily server. On this setup, assets equivalent to disk house, bandwidth, and processing energy are shared amongst a number of customers, making it a cheap choice for internet hosting small to medium-sized web sites.
Shared internet hosting environments are usually managed by internet hosting suppliers, who deal with server upkeep, safety, and technical help, permitting web site homeowners to concentrate on constructing and managing their web sites without having to fret about server administration duties.
Challenges of managing static information in shared internet hosting
Whereas shared internet hosting affords an inexpensive and handy internet hosting answer for a lot of web sites, it additionally has limitations in comparison with different varieties of internet hosting, equivalent to digital personal servers (VPS) or devoted servers. These limitations embrace the next:
Restrictions to server configurations and settings, limiting the power to customise server software program or set up further instruments.
Useful resource constraints equivalent to disk house additionally play a task, as there could be limitations on the quantity of bandwidth that can be utilized to serve these information to guests.
Efficiency could be one other problem in shared internet hosting, as a result of sharing assets with different customers may end up in slower load occasions for static information, particularly in periods of excessive site visitors or useful resource utilization.
Configuring to make use of WhiteNoise
WhiteNoise is a Python bundle that seamlessly integrates with Django, making it a super alternative for serving static information in shared internet hosting environments. Not like different software program installations equivalent to Apache and Nginx, which will not be permissible in sure internet hosting environments, WhiteNoise may be simply put in alongside your different challenge packages.
By configuring Django to make use of WhiteNoise, you possibly can effectively serve static information instantly out of your Django software with out the necessity for extra server software program. This simplifies the setup course of and ensures compatibility with a variety of internet hosting suppliers.
Most shared internet hosting suppliers present a cPanel that permits you to do server configurations and file uploads. So when you’ve uploaded your information, you can also make the next adjustments to the challenge settings.py file:
STATIC_URL=’static/’
STATIC_ROOT=’/house/username/public_html/static’
STATIC_ROOT=’/house/username/subdomain.mydomain.com/static’
With these settings in place, all you could do is run the collectstatic command in order that your static information will likely be collected into any of the above STATIC_ROOT directories, relying on the area.
Serving Static Recordsdata From AWS S3
Amazon Easy Storage Service (S3) is a scalable object storage service supplied by Amazon Internet Providers (AWS). It allows customers to create storage areas often known as buckets the place you possibly can retailer your varied varieties of information like paperwork, pictures, movies and notable for our tutorial static information.
AWS affords a free tier for a number of of its providers, together with Amazon S3. The free tier permits customers to get began with AWS providers for gratis for a sure interval or as much as particular utilization limits. To get began, you possibly can signup for the S3 free tier. Nonetheless, to finish the signup course of you’ll want to supply cost info.
Creating an S3 Bucket
To create a bucket, go to the S3 dashboard and click on on the Create bucket button.
Give the bucket a singular dns-compliant identify. You’ll be able to optionally choose a area nearer to you or your customers.
Allow ACL for the bucket.
Allow public entry for the bucket, by turning off Block all public entry.
Upon profitable creation, you must see your bucket on the primary S3 web page.
Enabling IAM entry
After creation of a bucket, you need to use the bucket as a root person, however AWS recommends you create an IAM (Id Entry Administration) person group and assign them entry to solely a selected bucket.
Creating IAM group
Go to the primary IAM web page and choose Consumer teams on the sidebar. Then click on the Create group button. Assign the group a reputation.
Then underneath Connect permisions polices, seek for S3 and assign AmazonS3FullAccess the clicking Create group button.
Creating IAM person
Whereas nonetheless on the IAM web page, choose Customers on the panel on the left and the clicking the Create person button.
Give the IAM person a reputation and click on the Subsequent button.
Beneath the Set permissions choice, depart the Add person to group as the chosen choice, then go to Consumer teams and choose the person group you created above after which click on the Subsequent button.
Assessment and click on Create person.
Now click on on the person identify to view the person particulars. Click on on the Safety credentials tab after which click on Create entry key. Select Native code and click on the Subsequent button.
After that, click on the Create entry key button. You’ll be able to copy the keys to your .env file in case you have one, or obtain the CSV file for later utilization.
Configuring Django to make use of AWS S3 for static information
After creating the S3 bucket, we have to configure the challenge to serve information from S3. Within the earlier part, we configured WhiteNoise to serve our static property. We have to disable WhiteNoise in order that we are able to serve the property from S3. To try this, go to the sitepoint_django/settings.py file and the remark out the related strains of code:
INSTALLED_APPS = [
]
MIDDLEWARE = [
]
The code above feedback out all of the settings we had put in place for WhiteNoise.
Putting in packages
For the challenge to have the ability to work with S3, we have to set up two packages: boto3 and django-storages. boto3 offers the low-level Python API for interacting with AWS providers, whereas django-storages extends Django’s file storage capabilities to combine with cloud storage suppliers like Amazon S3, permitting you to seamlessly handle and serve static and media information in your Django software:
pip set up boto3 django-storages
Configuring settings
For our challenge to have the ability to serve information from S3, we have to make a couple of adjustments to the settings.py file and replace it with the next code:
import os
STORAGES = {
‘staticfiles’: {
‘BACKEND’: ‘storages.backends.s3boto3.S3Boto3Storage’,
‘OPTIONS’: {
‘bucket_name’: os.getenv(‘AWS_STORAGE_BUCKET_NAME’),
‘location’: ‘static’,
‘querystring_auth’: False,
},
}
}
The settings above create a STORAGES dictionary that serves as a centralized configuration container for outlining varied storage backends used inside the challenge.
It’s necessary to notice this setting is barely out there for variations of Django from 4.2 and above. For earlier variations, go to the documentation.
Within the code above, we’ve got a setting for staticfiles which identifies the storage configuration for managing static information.
After the STORAGES settings we have to add some AWS-specific settings in our settings file, so scroll to the portion the place you’ll discover the STATIC_URL setting and the make the next adjustments:
USE_S3 = os.getenv(‘USE_S3’)
if USE_S3:
AWS_ACCESS_KEY_ID = os.getenv(‘AWS_ACCESS_KEY_ID’)
AWS_SECRET_ACCESS_KEY = os.getenv(‘AWS_SECRET_ACCESS_KEY’)
AWS_S3_OBJECT_PARAMETERS = {
“CacheControl”: “max-age=2592000”,
}
else:
STATIC_URL = ‘static/’
STATIC_ROOT = BASE_DIR / ‘staticfiles’
Importing static information to S3
As soon as the settings are in place, the subsequent activity is to add your static information to the S3 bucket. You do this by working collectstatic:
python handle.py collectstatic –no-input
This may gather all static information in our challenge’s apps, transfer them into the S3 bucket, and put them right into a static folder as outlined within the STORAGES dictionary. The no –no-input flag instructs Django to run in non-interactive mode, bypassing any prompts for person enter.
When used, Django will routinely proceed with that static information collections course of with out requiring any handbook intervention from the person.
Operating the challenge
As soon as all of the settings are in place, you possibly can run the challenge. Let’s run the challenge in improvement and serve the information from the S3 bucket:
python handle.py runserver
To confirm that you’re certainly serving information from S3, you possibly can view the supply code of the house web page:
<hyperlink rel=”stylesheet” href=”https://sitepoint-django-static.s3.amazonaws.com/static/static_demo/css/kinds.css”>
<img src=”https://sitepoint-django-static.s3.amazonaws.com/static/static_demo/pictures/flowerImage.png” alt=”Flower Picture”>
<script src=”https://sitepoint-django-static.s3.amazonaws.com/static/static_demo/js/todays_date.js”></script>
Wanting on the HTML parts reveals that certainly the URLs level to the S3 bucket.
Conclusion
In abstract, managing static information in Django entails assessing challenge necessities, scalability wants, and internet hosting surroundings constraints to decide on essentially the most appropriate technique.
For instance, WhiteNoise middleware offers an environment friendly answer for serving static information in shared internet hosting environments, the place useful resource constraints and restricted server entry could pose challenges.
By configuring Django settings appropriately and leveraging instruments like WhiteNoise, builders can guarantee dependable and optimized static file serving, whatever the internet hosting surroundings. Every technique affords its personal benefits and issues, requiring cautious analysis to satisfy the precise wants of the challenge and ship a seamless person expertise.
We’ve coated a number of key factors:
Strategies for managing static information. We’ve mentioned varied approaches, together with serving static information domestically, utilizing Django’s built-in improvement server, leveraging third-party storage options like Amazon S3, and serving information utilizing packages like WhiteNoise. Every technique has its personal benefits and issues, relying on components equivalent to scalability, efficiency, and ease of deployment.
Widespread settings and instructions:
STATIC_ROOT: specifies the listing the place collected static information will likely be saved.
STATIC_URL: defines the bottom URL for accessing static information by way of the net server.
STATICFILES_DIRS: specifies further directories containing static property.
STATICFILES_STORAGE: configures the storage backend for dealing with static information.
collectstatic: collects all static property from all app directories to the STATIC_ROOT.
Additional studying:
[ad_2]
Supply hyperlink
