Deploying Python Applications with Gunicorn
Python
23.10.2024
Reading time: 7 min
Share
In this article, we’ll show how to set up an Ubuntu 20.04 server and install and configure the components required for deploying Python applications. We’ll configure the WSGI server Gunicorn to interact with our application. Gunicorn will serve as an interface that converts client requests via the HTTP protocol into Python function calls executed by the application. Then, we will configure Nginx as a reverse proxy server for Gunicorn, which will forward requests to the Gunicorn server. Additionally, we will cover securing HTTP connections with an SSL certificate or using other features like load balancing, caching, etc. These details can be helpful when working with cloud services like those provided by Hostman.
Creating a Python Virtual Environment
To begin, we need to update all packages:
sudo apt updateUbuntu provides the latest version of the Python interpreter by default. Let’s check the installed version using the following command:
python3 --versionExample output:
Python 3.10.12We’ll set up a virtual environment to ensure that our project has its own dependencies, separate from other projects. First, install the virtualenv package, which allows you to create virtual environments:
sudo apt-get install python3-venv python3-devNext, create a folder for your project and navigate into it:
mkdir myapp
cd myappNow, create a virtual environment:
python3 -m venv venvAnd create a folder for your project:
mkdir appYour project directory should now contain two items: app and venv.
You can verify this using the standard Linux command to list directory contents:
lsExpected output:
myapp venvYou need to activate the virtual environment so that all subsequent components are installed locally for the project:
source venv/bin/activateInstalling and Configuring Gunicorn
Gunicorn (Green Unicorn) is a Python WSGI HTTP server for UNIX. It is compatible with various web frameworks, fast, easy to implement, and uses minimal server resources.
To install Gunicorn, run the following command:
pip install gunicornWSGI and Python
WSGI (Web Server Gateway Interface) is the standard interface between a Python application running on the server side and the web server itself, such as Nginx. A WSGI server interacts with the application, allowing you to run code when handling requests. Typically, the application is provided as an object named application in a Python module, which is made available to the server.
In the standard wsgi.py file, there is usually a callable application. For example, let’s create such a file using the nano text editor:
nano wsgi.pyAdd the following simple code to the file:
from aiohttp import web
async def index(request):
return web.Response(text="Welcome home!")
app = web.Application()
app.router.add_get('/', index)
In the code above, we import aiohttp, a library that provides an asynchronous HTTP client built on top of asyncio. HTTP requests are a classic example of where asynchronous handling is ideal, as they involve waiting for server responses, during which other code can execute efficiently. This library allows sequential requests to be made without waiting for the first response before sending a new one. It’s common to run aiohttp servers behind Nginx.
Running the Gunicorn Server
You can launch the server using the following command template:
gunicorn [OPTIONS] [WSGI_APP]Here, [WSGI_APP] consists of $(MODULE_NAME):$(VARIABLE_NAME) and [OPTIONS] is a set of parameters for configuring Gunicorn.
A simple command would look like this:
gunicorn wsgi:appTo restart Gunicorn, you can use:
sudo systemctl restart gunicornSystemd Integration
systemdis a system and service manager that allows for strict control over processes, resources, and permissions. We’ll create a socket thatsystemdwill listen to, automatically starting Gunicorn in response to traffic.
Configuring the Gunicorn Service and Socket
First, create the service configuration file:
sudo nano /etc/systemd/system/gunicorn.serviceAdd the following content to the file:
[Unit]
Description=gunicorn daemon
Requires=gunicorn.socket
After=network.target
[Service]
Type=notify
User=someuser
Group=someuser
RuntimeDirectory=gunicorn
WorkingDirectory=/home/someuser/myapp
ExecStart=/path/to/venv/bin/gunicorn wsgi:app
ExecReload=/bin/kill -s HUP $MAINPID
KillMode=mixed
TimeoutStopSec=5
PrivateTmp=true
[Install]
WantedBy=multi-user.target
Make sure to replace /path/to/venv/bin/gunicorn with the actual path to the Gunicorn executable within your virtual environment. It will likely look something like this: /home/someuser/myapp/venv/bin/gunicorn.
Next, create the socket configuration file:
sudo nano /etc/systemd/system/gunicorn.socketAdd the following content:
[Unit]
Description=gunicorn socket
[Socket]
ListenStream=/run/gunicorn.sock
SocketUser=www-data
[Install]
WantedBy=sockets.target
Enable and start the socket with:
systemctl enable --now gunicorn.socketConfiguring Gunicorn
Let's review some useful parameters for Gunicorn in Python 3. You can find all possible parameters in the official documentation.
Sockets
-b BIND,--bind=BIND— Specifies the server socket. You can use formats like:$(HOST),$(HOST):$(PORT).
Example:
gunicorn --bind=127.0.0.1:8080 wsgi:appThis command will run your application locally on port 8080.
Worker Processes
-w WORKERS,--workers=WORKERS— Sets the number of worker processes. Typically, this number should be between 2 to 4 per server core.
Example:
gunicorn --workers=2 wsgi:appProcess Type
-k WORKERCLASS,--worker-class=WORKERCLASS— Specifies the type of worker process to run.
By default, Gunicorn uses the sync worker type, which is a simple synchronous worker that handles one request at a time. Other worker types may require additional dependencies.
Asynchronous worker processes are available using Greenlets (via Eventlet or Gevent). Greenlets are a cooperative multitasking implementation for Python. The corresponding parameters are eventlet and gevent.
We will use an asynchronous worker type compatible with aiohttp:
gunicorn wsgi:app --bind localhost:8080 --worker-class aiohttp.GunicornWebWorkerAccess Logging
You can enable access logging using the --access-logfile flag.
Example:
gunicorn wsgi:app --access-logfile access.logError Logging
To specify an error log file, use the following command:
gunicorn wsgi:app --error-logfile error.logYou can also set the verbosity level of the error log output using the --log-level flag. Available log levels in Gunicorn are:
-
debug
-
info
-
warning
-
error
-
critical
By default, the info level is set, which omits debug-level information.
Installing and Configuring Nginx
First, install Nginx with the command:
sudo apt install nginxLet’s check if the Nginx service can connect to the socket created earlier:
sudo -u www-data curl --unix-socket /run/gunicorn.sock httpIf successful, Gunicorn will automatically start, and you'll see the HTML code from the server in the terminal.
Nginx configuration involves adding config files for virtual hosts. Each proxy configuration should be stored in the /etc/nginx/sites-available directory.
To enable each proxy server, create a symbolic link to it in /etc/nginx/sites-enabled. When Nginx starts, it automatically loads all proxy servers in this directory.
Create a new configuration file:
sudo nano /etc/nginx/sites-available/myconfig.confThen create a symbolic link with the command:
sudo ln -s /etc/nginx/sites-available/myconfig.conf /etc/nginx/sites-enabledNginx must be restarted after any changes to the configuration file to apply the new settings.
First, check the syntax of the configuration file:
nginx -tThen reload Nginx:
nginx -s reloadConclusion
Gunicorn is a robust and versatile WSGI server for deploying Python applications, offering flexibility with various worker types and integration options like Nginx for load balancing and reverse proxying. Its ease of installation and configuration, combined with detailed logging and scaling options, make it an excellent choice for production environments. By utilizing Gunicorn with frameworks like aiohttp and integrating it with Nginx, you can efficiently serve Python applications with improved performance and resource management.
Python
23.10.2024
Reading time: 7 min
Share
Similar
Python
The Walrus Operator in Python
The first question newcomers often ask about the walrus operator in Python is: why such a strange name? The answer lies in its appearance. Look at the Python walrus operator: :=. Doesn't it resemble a walrus lounging on a beach, with the symbols representing its "eyes" and "tusks"? That's how it earned the name.
How the Walrus Operator Works
Introduced in Python 3.8, the walrus operator allows you to assign a value to a variable while returning that value in a single expression. Here's a simple example:
print(apples = 7)
This would result in an error because print expects an expression, not an assignment. But with the walrus operator:
print(apples := 7)
The output will be 7. This one-liner assigns the value 7 to apples and returns it simultaneously, making the code compact and clear.
Practical Examples
Let’s look at a few examples of how to use the walrus operator in Python.
Consider a program where users input phrases. The program stops if the user presses Enter. In earlier versions of Python, you'd write it like this:
expression = input('Enter something or just press Enter: ')
while expression != '':
print('Great!')
expression = input('Enter something or just press Enter: ')
print('Bored? Okay, goodbye.')
This works, but we can simplify it using the walrus operator, reducing the code from five lines to three:
while (expression := input('Enter something or just press Enter: ')) != '':
print('Great!')
print('Bored? Okay, goodbye.')
Here, the walrus operator allows us to assign the user input to expression directly inside the while loop, eliminating redundancy.
Key Features of the Walrus Operator:
The walrus operator only assigns values within other expressions, such as loops or conditions.
It helps reduce code length while maintaining clarity, making your scripts more efficient and easier to read.
Now let's look at another example of the walrus operator within a conditional expression, demonstrating its versatility in Python's modern syntax.
Using the Walrus Operator with Conditional Constructs
Let’s write a phrase, assign it to a variable, and then find a word in this phrase using a condition:
phrase = 'But all sorts of things and weather must be taken in together to make up a year and a sphere...'
word = phrase.find('things')
if word != -1:
print(phrase[word:])
The expression [word:] allows us to get the following output:
things and weather must be taken in together to make up a year and a sphere...
Now let's shorten the code using the walrus operator. Instead of:
word = phrase.find('things')
if word != -1:
print(phrase[word:])
we can write:
if (word := phrase.find('things')) != -1:
print(phrase[word:])
In this case, we saved a little in volume but also reduced the number of lines. Note that, despite the reduced time for writing the code, the walrus operator doesn’t always simplify reading it. However, in many cases, it’s just a matter of habit, so with practice, you'll learn to read code with "walruses" easily.
Using the Walrus Operator with Numeric Expressions
Lastly, let’s look at an example from another area where using the walrus operator helps optimize program performance: numerical operations. We will write a simple program to perform exponentiation:
def pow(number, power):
print('Calling pow')
result = 1
while power:
result *= number
power -= 1
return result
Now, let’s enter the following in the interpreter:
>>> [pow(number, 2) for number in range(3) if pow(number, 2) % 2 == 0]
We get the following output:
Calling pow
Calling pow
Calling pow
Calling pow
Calling pow
[0, 4, 16]
Now, let's rewrite the input in the interpreter using the walrus operator:
>>> [p for number in range(3) if (p := pow(number, 2)) % 2 == 0]
Output:
Calling pow
Calling pow
Calling pow
[0, 4, 16]
As we can see, the code hasn’t shrunk significantly, but the number of function calls has nearly been halved, meaning the program will run faster!
Conclusion
In conclusion, the walrus operator (:=) introduced in Python 3.8 streamlines code by allowing assignment and value retrieval in a single expression. This operator enhances readability and efficiency, particularly in loops and conditional statements. Through practical examples, we’ve seen how it reduces line counts and minimizes redundant function calls, leading to faster execution. With practice, developers can master the walrus operator, making their code cleaner and more concise.
23 October 2024 · 4 min to read
Python
Python String Functions
As the name suggests, Python 3 string functions are designed to perform various operations on strings. There are several dozen string functions in the Python programming language. In this article, we will cover the most commonly used ones and several special functions that may be less popular but are still useful. They can be helpful not only for formatting but also for data validation.
List of Basic String Functions for Text Formatting
First, let’s discuss string formatting functions, and to make the learning process more enjoyable, we will use texts generated by a neural network in our examples.
capitalize() — Converts the first character of the string to uppercase, while all other characters will be in lowercase:
>>> phrase = 'the shortage of programmers increases the significance of DevOps. After the presentation, developers start offering their services one after another, competing with each other for DevOps.'
>>> phrase.capitalize()
'The shortage of programmers increases the significance of devops. after the presentation, developers start offering their services one after another, competing with each other for devops.'
casefold() — Returns all elements of the string in lowercase:
>>> phrase = 'Cloud providers offer scalable computing resources and services over the internet, enabling businesses to innovate quickly. They support various applications, from storage to machine learning, while ensuring reliability and security.'
>>> phrase.casefold()
'cloud providers offer scalable computing resources and services over the internet, enabling businesses to innovate quickly. they support various applications, from storage to machine learning, while ensuring reliability and security.'
center() — This method allows you to center-align strings:
>>> text = 'Python is great for writing AI'
>>> newtext = text.center(40, '*')
>>> print(newtext)
*****Python is great for writing AI*****
A small explanation: The center() function has two arguments: the first (length of the string for centering) is mandatory, while the second (filler) is optional. In the operation above, we used both. Our string consists of 30 characters, so the remaining 10 were filled with asterisks. If the second attribute were omitted, spaces would fill the gaps instead.
upper() and lower() — convert all characters to uppercase and lowercase, respectively:
>>> text = 'Projects using Internet of Things technology are becoming increasingly popular in Europe.'
>>> text.lower()
'projects using internet of things technology are becoming increasingly popular in europe.'
>>> text.upper()
'PROJECTS USING INTERNET OF THINGS TECHNOLOGY ARE BECOMING INCREASINGLY POPULAR IN EUROPE.'
replace() — is used to replace a part of the string with another element:
>>> text.replace('Europe', 'USA')
'Projects using Internet of Things technology are becoming increasingly popular in the USA.'
The replace() function also has an optional count attribute that specifies the maximum number of replacements if the element to be replaced occurs multiple times in the text. It is specified in the third position:
>>> text = 'hooray hooray hooray'
>>> text.replace('hooray', 'hip', 2)
'hip hip hooray'
strip() — removes identical characters from the edges of a string:
>>> text = 'ole ole ole'
>>> text.strip('ole')
'ole'
If there are no symmetrical values, it will remove what is found on the left or right. If the specified characters are absent, the output will remain unchanged:
>>> text.strip('ol')
'e ole ole'
>>> text.strip('le')
'ole ole o'
>>> text.strip('ura')
'ole ole ole'
title() — creates titles, capitalizing each word:
>>> texttitle = 'The 5G revolution: transforming connectivity. How next-gen networks are shaping our digital future'
>>> texttitle.title()
'The 5G Revolution: Transforming Connectivity. How Next-Gen Networks Are Shaping Our Digital Future'
expandtabs() — changes tabs in the text, which helps with formatting:
>>> clublist = 'Milan\tReal\tBayern\tArsenal'
>>> print(clublist)
Milan Real Bayern Arsenal
>>> clublist.expandtabs(1)
'Milan Real Bayern Arsenal'
>>> clublist.expandtabs(5)
'Milan Real Bayern Arsenal'
String Functions for Value Checking
Sometimes, it is necessary to count a certain number of elements in a sequence or check if a specific value appears in the text. The following string functions solve these and other tasks.
count() — counts substrings (individual elements) that occur in a string. Let's refer again to our neural network example:
>>> text = "Cloud technologies significantly accelerate work with neural networks and AI. These technologies are especially important for employees of large corporations operating in any field — from piloting spacecraft to training programmers."
>>> element = "o"
>>> number = text.count(element)
>>> print("The letter 'o' appears in the text", number, "time(s).")
The letter 'o' appears in the text 19 time(s).
As a substring, you can specify a sequence of characters (we'll use text from the example above):
>>> element = "ob"
>>> number = text.count(element)
>>> print("The combination 'ob' appears in the text", number, "time(s).")
The combination 'in' appears in the text 5 time(s).
Additionally, the count() function has two optional numerical attributes that specify the search boundaries for the specified element:
>>> element = "o"
>>> number = text.count(element, 20, 80)
>>> print("The letter 'o' appears in the specified text fragment", number, "time(s).")
The letter 'o' appears in the specified text fragment 6 time(s).
The letter 'o' appears in the specified text fragment 6 time(s).
find() — searches for the specified value in the string and returns the smallest index. Again, we will use the example above:
>>> print(text.find(element))
7
This output means that the first found letter o is located at position 7 in the string (actually at position 8, because counting in Python starts from zero). Note that the interpreter ignored the capital letter O, which is located at position zero.
Now let's combine the two functions we've learned in one code:
>>> text = "Cloud technologies significantly accelerate work with neural networks and AI. These technologies are especially important for employees of large corporations operating in any field — from piloting spacecraft to training programmers."
>>> element = "o"
>>> number = text.count(element, 20, 80)
>>> print("The letter 'o' appears in the specified text fragment", number, "time(s), and the first time in the whole text at", (text.find(element)), "position.")
The letter 'o' appears in the specified text fragment 3 time(s), and the first time in the whole text at 7 position.
index() — works similarly to find(), but will raise an error if the specified value is absent:
Traceback (most recent call last):
File "C:\Python\text.py", line 4, in <module>
print(text.index(element))
ValueError: substring not found
Here's what the interpreter would return when using the find() function in this case:
-1
This negative position indicates that the value was not found.
enumerate() — a very useful function that not only iterates through the elements of a list or tuple, returning their values, but also returns the ordinal number of each element:
team_scores = [78, 74, 56, 53, 49, 47, 44]
for number, score in enumerate(team_scores, 1):
print(str(number) + '-th team scored ' + str(score) + ' points.')
To output the values with their ordinal numbers, we introduced a few variables: number for ordinal numbers, score for the values of the list, and str indicates a string. And here’s the output:
1-th team scored 78 points.
2-th team scored 74 points.
3-th team scored 56 points.
4-th team scored 53 points.
5-th team scored 49 points.
6-th team scored 47 points.
7-th team scored 44 points.
Note that the second attribute of the enumerate() function is the number 1, otherwise Python would start counting from zero.
len() — counts the length of an object, i.e., the number of elements that make up a particular sequence:
>>> len(team_scores)
7
This way, we counted the number of elements in the list from the example above. Now let's ask the neural network to write a string again and count the number of characters in it:
>>> network = 'It is said that artificial intelligence excludes the human factor. But do not forget that the human factor is still present in the media and government structures.'
>>> len(network)
162
Special String Functions in Python
join() — allows you to convert lists into strings:
>>> cities = ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix', 'Philadelphia', 'San Antonio']
>>> cities_str = ', '.join(cities)
>>> print('Cities in one line:', cities_str)
Cities in one line: New York, Los Angeles, Chicago, Houston, Phoenix, Philadelphia, San Antonio
print() — provides a printed representation of any object in Python:
>>> cities = ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix', 'Philadelphia', 'San Antonio']
>>> print(cities)
['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix', 'Philadelphia', 'San Antonio']
type() — returns the type of the object:
>>> type(cities)
<class 'list'>
We found out that the object from the previous example is a list. This is useful for beginners, as they may initially confuse lists with tuples, which have different functionalities and are handled differently by the interpreter.
map() — is a fairly efficient replacement for a for loop, allowing you to iterate over the elements of an iterable object, applying a built-in function to each of them. For example, let's convert a list of string values into integers using the int function:
>>> numbers_list = ['4', '7', '11', '12', '17']
>>> list(map(int, numbers_list))
[4, 7, 11, 12, 17]
As we can see, we used the list() function, "wrapping" the map() function in it—this was necessary to avoid the following output:
>>> numbers_list = ['4', '7', '11', '12', '17']
>>> map(int, numbers_list)
<map object at 0x0000000002E272B0>
This is not an error; it simply produces the ID of the object, and the program will continue to run. However, the list() method is useful in such cases to get the desired list output.
Of course, we haven't covered all string functions in Python. Still, this set will already help you perform a large number of operations with strings and carry out various transformations (programmatic and mathematical).
23 October 2024 · 9 min to read
Python
Installing Anaconda Python on Ubuntu
Anaconda is a popular platform for data processing and machine learning. It supports Python and R programming languages and is used for large-scale data processing, predictive analytics, and scientific computing. You can install it on a local machine or scalable cloud servers from Hostman.
The Python distribution comes with 250 open-source data packages, and you can install over 7,500 additional packages from Anaconda repositories. It also includes the Conda package manager and the graphical user interface, Anaconda Navigator.
In this guide, you'll learn how to install the Anaconda distribution on the latest versions of Ubuntu.
Downloading the Anaconda Distribution
There are three options to download the Anaconda script:
Download via a browser.
Download using wget.
Download using curl.
To download the distribution via a browser, go to the official Anaconda website in the Distribution section. Enter your email, and you’ll receive a download link. Download the 64-bit (x86) Installer for Linux.
To download the distribution using the wget utility, use the following command:
wget https://repo.anaconda.com/archive/Anaconda3-2024.06-1-Linux-x86_64.sh --output anaconda.sh
When downloading, it’s important to specify the correct version. This command requests version 2024.06, which is the latest at the time of writing. If you need another version, specify its number (e.g., 2022.05). You can find the version number and changes on the Release Notes page in the documentation.
Pay attention to the syntax. In the end, we specify --output anaconda.sh, which is an optional argument that renames the file Anaconda3-2024.06-Linux-x86_64.sh to anaconda.sh for convenience, so you don’t have to type a long, complex filename during installation.
To verify the integrity of the data, compare the cryptographic hash using the checksum (optional step). To see the SHA-256 checksum, run:
sha256sum anaconda.sh
The terminal will display a line of numbers and letters. Compare this checksum with the one provided on the Anaconda website for the corresponding version. If the hash doesn’t match, the file may not have been downloaded completely. Download it again and recheck the checksum.
Installing Anaconda
To work with Anaconda, you can use the graphical interface Navigator. For it to work correctly on Ubuntu, you need to install additional packages:
sudo apt install libgl1-mesa-glx libegl1-mesa libxrandr2 libxss1 libxcursor1 libxcomposite1 libasound2 libxi6 libxtst6
If you don’t plan to use the graphical interface, these packages are not necessary.
Now that you have the distribution file, it's time to deploy the package manager with all components. Regardless of how you downloaded the distribution, deployment is done with a single command:
bash anaconda.sh
The installation runs in dialog mode. First, you’ll be prompted to press Enter to continue. Then, press Enter to read the license agreement. If you agree to the terms, type 'yes' and press Enter again.
The next step is choosing the installation location. You can accept the default directory by pressing Enter. If you want to specify a different folder, enter the full path.
Installing Anaconda takes a few minutes. After completion, you'll be prompted to initialize Anaconda. Type 'yes' and press Enter. The installation wizard will automatically make the necessary changes to all required directories.
Activating the Installation
Activation refers to adding a new PATH variable. This allows the system to recognize commands given to Anaconda and its components. To activate, run the following command:
source ~/.bashrc
After activation, the environment variables will be updated. Visually, this change is reflected by the appearance of the word base before the username.
To confirm the installation was successful, run:
conda list
The screen will display a list of all the installed Anaconda components.
Setting Up a Virtual Environment
By default, Anaconda uses the base environment for work. Working in a single environment can be inconvenient if you have multiple projects with different packages and versions. Anaconda Python virtual environments solve this issue. For each environment, you can specify the Python version, as well as the composition and versions of all packages.
For example, if you have a project on a Hostman server that uses Python 3.9, you can create a dedicated virtual environment for it with the following command:
conda create -n new_env python=3.9
The syntax is quite simple:
create: the command to create a virtual environment;
-n: the argument followed by the name of the new environment, in this case, new_env;
python=3.9: specifies the version of Python to be used inside the virtual environment.
After running the command, information about the packages to be installed will be displayed. If you agree with the list, type 'yes' and press Enter.
To switch to the environment, you need to activate it:
conda activate new_env
To exit the environment, deactivate it:
conda deactivate
Inside the environment, you can install the packages needed for your project. There are two ways to do this:
Activate the environment and install packages within it.
Specify the environment's name when installing a package. For example:
conda install --name new_env numpy
This command can be run from the base environment, but the numpy library will be installed inside new_env.
You can create as many virtual environments as needed for your Anaconda projects. To display a full list of environments, use the command:
conda info --envs
The current environment will be marked with an asterisk (*).
Updating Anaconda
Updating Anaconda is a simple task. Open the terminal and run the following command:
conda update --all
If updates are available for Anaconda in Python 3, they will be displayed in a list. To confirm the installation of updates, type 'y' and press Enter.
You can also update package manager components individually. For example, if you know there’s a new version of the conda command-line utility, update it with the command:
conda update conda
To update the entire distribution without checking the list of updates, use this command:
conda update anaconda
Remember to check for updates periodically to ensure you're using the latest versions of tools.
Complete Removal of Anaconda
There are two ways to uninstall the Anaconda package manager. Let’s review both.
Method 1: Manual Removal
Remove the installation directory and all other files created during installation with the following command:
rm -rf ~/anaconda3 ~/.condarc ~/.conda ~/.continuum
Method 2: Using anaconda-clean
This method is a bit more automated. You can use the anaconda-clean module to ensure all components are completely removed from the system. It helps remove configuration files. After that, you just need to delete the anaconda3 directory.
First, install the module:
install anaconda-clean
To confirm the removal, enter 'y' in the prompt and press Enter.
Run the module after installation with the following command:
anaconda-clean
The uninstaller will ask for confirmation before deleting each component. To avoid having to enter 'y' repeatedly, add the flag for automatic confirmation:
anaconda-clean --yes
After the cleanup, a backup folder will appear in the user's home directory. Inside, you’ll find a backup of the last saved state, in case you change your mind and want to restore Anaconda on Ubuntu.
Once the cleaning module has finished, you can finally delete the package manager directory:
rm -rf ~/anaconda3
To completely remove all traces of Anaconda from the system, also delete the PATH entry from the .bashrc file. This entry is added by default during installation.
Open the .bashrc file in any text editor. In this example, we'll use nano:
nano ~/.bashrc
Look for the lines where conda is initialized. If Anaconda was installed recently, these lines will be near the end of the file. To speed up the search, use the Ctrl+W key combination. The lines will look something like this:
# >>> conda initialize >>>
# !! Contents within this block are managed by 'conda init' !!
__conda_setup="$('/home/linux/anaconda3/bin/conda' 'shell.bash' 'hook' 2> /dev/null)"
if [ $? -eq 0 ]; then
eval "$__conda_setup"
else
if [ -f "/home/linux/anaconda3/etc/profile.d/conda.sh" ]; then
. "/home/linux/anaconda3/etc/profile.d/conda.sh"
else
export PATH="/home/linux/anaconda3/bin:$PATH"
fi
fi
unset __conda_setup
# <<< conda initialize <<<
Delete or comment out these lines in the file. To save changes in nano, press Ctrl + X and confirm the overwrite. The removal of Anaconda is now complete.
Conclusion
In this tutorial, we covered the key steps from installing Anaconda to fully removing it. Now you can properly install the package manager in your system, keep it up to date, and, if needed, completely remove the software components from Ubuntu.
23 October 2024 · 7 min to read
Do you have questions,
comments, or concerns?
Our professionals are available to assist you at any moment,
whether you need help or are just unsure of where to start.
whether you need help or are just unsure of where to start.
