Technology

Welcome to our comprehensive guide on installing ERPNext Version 15 on Ubuntu 24.04. ERPNext is a powerful, open-source ERP system that streamlines business processes from inventory management to accounting. Whether you’re new to ERPNext or you have worked with it for years, this step-by-step tutorial will walk you through the installation process, ensuring you have everything set up correctly on your Ubuntu 24.04 system. Let’s dive in and get ERPNext up and running efficiently!

Prerequisites

The below prerequisites are advised in order to get an optimal functionality of ERPNext on your server.

Software Requirements

• Updated Ubuntu 24.04
• A user with sudo privileges
• Python 3.11+
• pip 20+
• MariaDB 10.3.x
• Node.js 18
• yarn 1.12+

Hardware Requirements

• 4GB RAM
• 40GB Hard Disk

Server Settings

Update and Upgrade Packages

sudo apt-get update -y
sudo apt-get upgrade -y

Create a new user – (bench user)

In Linux, the root user processes escalated privileges to perform any tasks within the system. This is why it is not advisable to use this user on a daily basis. We will create a user that we can use, and this will be the user we will also use as the Frappe Bench User.

sudo adduser [frappe-user]
usermod -aG sudo [frappe-user]
su [frappe-user] 
cd /home/[frappe-user]

Ensure you have replaced [frappe-user] with your username. eg. sudo adduser frappe

Install Required Packages

A software like ERPNext, which is built on Frappe Framework, requires a number of packages in order to run smoothly. These are the packages we will be installing in this step.

Install GIT

sudo apt-get install git -y

Install Python Dependencies

Installing ERPNext version 15 on Ubuntu 24.04 requires Python version 3.11+. This is what we will install in this step.

python-dev

sudo apt-get install python3-dev -y

setuptools and pip

sudo apt-get install python3-setuptools python3-pip -y

virtualenv

sudo apt install python3.12-venv -y

Install MariaDB

ERPNext is built to naively run on MariaDB. Lets go ahead and set that up now.

sudo apt-get install software-properties-common -y
sudo apt install mariadb-server -y
sudo mysql_secure_installation

• When you run this command, the server will show the following prompts. Please follow the steps as shown below to complete the setup correctly.
• Enter current password for root: (Enter your SSH root user password)
• Switch to unix_socket authentication [Y/n]: Y
• Change the root password? [Y/n]: Y
  It will ask you to set new MySQL root password at this step. This can be different from the SSH root user password.
• Remove anonymous users? [Y/n] Y
• Disallow root login remotely? [Y/n]: N
  This is set as N because we might want to access the database from a remote server for using business analytics software like Metabase / PowerBI / Tableau, etc.
• Remove test database and access to it? [Y/n]: Y
• Reload privilege tables now? [Y/n]: Y

Edit MYSQL default config file

sudo nano /etc/mysql/my.cnf

Add the following block of code to the end of the file, exactly as is:

[mysqld]
character-set-client-handshake = FALSE
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci

[mysql]
default-character-set = utf8mb4

Restart the MYSQL Server

sudo service mysql restart

Install Redis Server

sudo apt-get install redis-server -y

Instal CURL, Node, NPM and Yarn

Install CURL

sudo apt install curl

Install Node

curl https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash

source ~/.profile

nvm install 18

Install NPM

sudo apt-get install npm -y

Install Yarn

sudo npm install -g yarn -y

Install wkhtmltopdf

sudo apt-get install xvfb libfontconfig wkhtmltopdf -y

Install Frappe Bench

In this step, we need to supply the – H and –break-system-packages flags. The flags do the following:

• -H: Sets the HOME environment variable to the home directory of the target user. This ensures that the package installation happens in the correct directory and avoids permission issues.
• --break-system-packages: Overrides the default behavior of pip to avoid breaking system packages. This flag is used to indicate that you are aware that this installation might cause conflicts with the system package manager, but you want to proceed anyway.

sudo -H pip3 install frappe-bench --break-system-packages

Install ansible

sudo -H pip3 install ansible --break-system-packages

Initialize Frappe Bench

bench init frappe-bench --frappe-branch version-15

Switch directories into the Frappe Bench directory

cd frappe-bench

Change user directory permissions

This will give the bench user execution permission to the home directory.

chmod -R o+rx /home/[frappe-user]

Create a New Site

A site is a requirement in ERPNext, Frappe and all the other apps we will be needing to install. We will create the site in this step.

bench new-site [site-name]

Install ERPNext and other Apps

Download all the apps we want to install

The first app we will download is the payments app. This app is required when setting up ERPNext.

bench get-app payments

Next, we will download ERPNext app

bench get-app --branch version-15 erpnext

Download any other app you may be interested in in a similar manner. For instance, if you need the Human Resource app to be installed, use the following command.

bench get-app hrms

Install all the apps on our site

bench --site [site-name] install-app erpnext

Install all the other apps you downloaded in the same way. For example, if you downloaded the human resource app, use the below command to install it.

bench --site [site-name] install-app hrms

We have successfully setup ERPNext version 15 on ubuntu 24.04. You can start the server by running the below command:

bench start

If you didn’t have any other ERPNext instance running on the same server, ERPNext will get started on port 8000. If you visit [YOUR SERVER IP:8000], you should be able to see ERPNext version 15 running.

Please note that instances which are running on develop mode, like the one we just setup, will not get started when you restart your server. You will need to run the bench start command every time the server restarts.

In the below steps, we will learn how to deploy the production mode.

Setting ERPNext for Production

Enable Scheduler

bench --site [site-name] enable-scheduler

Disable maintenance mode

bench --site [site-name] set-maintenance-mode off

Setup production config

sudo bench setup production [frappe-user]

Setup NGINX to apply the changes

bench setup nginx

Restart Supervisor and Launch Production Mode

sudo supervisorctl restart all
sudo bench setup production [frappe-user]

If you are prompted to save the new/existing config file, respond with a Y.

When this completes doing the settings, your instance is now on production mode and can be accessed using your IP, without needing to use the port.

This also will mean that your instance will start automatically even in the event you restart the server.

If you would like to install an SSL certificate on your site, use this tutorial to do that.

All the best! 🙂

ERROR! [DEPRECATED]: ansible.builtin.include has been removed. Use include_tasks or import_tasks instead. This feature was removed from ansible-core in a release after 2023-05-16. Please update your playbooks.

If you are experiencing the error “ERROR! [DEPRECATED]: ansible.builtin.include has been removed,” don’t panic. This blog post will guide you through this update and ensure your deployments continue smoothly.

Understanding the Error

This error arises because Ansible, a popular infrastructure automation tool, has deprecated the include module in favor of include_tasks and import_tasks. This means the old way of including tasks from other YAML files is no longer recommended.

Why the Change?

Ansible’s developers aim to improve code clarity and maintainability with this update. The new modules offer better structure and separation of concerns.

Fixing the Error: Updating Your Playbooks

To resolve this error, you need to replace instances of include with either include_tasks or import_tasks in your main.yml file. Here’s a quick breakdown:

• include_tasks: Use this when you want to include a file containing a list of tasks that will be executed in the current context.
• import_tasks: This is ideal when you want to import tasks from another file and add them to the current playbook for later execution.

Don’t worry, the specific changes you need to make are covered in detail in my YouTube video (link in the description below)!

Bonus: Free Updated main.yml File

For your convenience, I’ve provided a fully updated main.yml file on my GitHub repository (link in the description below). This file incorporates the necessary changes to address the deprecated include module.

By following these steps and utilizing the provided resources, you’ll have your Ansible playbooks running smoothly and up-to-date with the latest Ansible practices!

By following these steps and utilizing the provided resources, you’ll have your Ansible playbooks running smoothly and up-to-date with the latest Ansible practices!

GitHub repo: VIEW ON GITHUB

Implementing ERPNext, a robust and comprehensive ERP system, is a critical decision for any organization. The approach to implementation can significantly impact the success of the project and the overall business operations. There are two primary methods to implement ERPNext: Phased Implementation and Big Bang Implementation. This blog post delves into a detailed comparison of these two approaches to help you make an informed decision.

1. Risk Management

Phased Implementation:

• Lower Risk: By implementing ERPNext in phases, the risk is spread out over time. Each phase is a smaller, manageable project, allowing for early detection and mitigation of issues.
• Gradual Adaptation: Users can gradually adapt to the new system, reducing the likelihood of resistance and errors.

Big Bang Implementation:

• Higher Risk: All modules go live at once, making it a high-risk approach. Any issues can affect the entire organization simultaneously.
• Immediate Impact: Users must adapt quickly to the new system, which can lead to resistance and a higher chance of errors.

2. Cost Implications

Phased Implementation:

• Incremental Costs: Costs are spread over a longer period, which can be easier to manage and budget for. Each phase requires its own set of resources and potentially additional temporary costs.
• Ongoing Costs: Extended project timelines can result in higher overall costs due to prolonged use of consultants and support.

Big Bang Implementation:

• Upfront Costs: High initial investment as all modules are implemented at once. This can strain budgets and cash flow.
• One-Time Costs: Potentially lower overall costs as the project duration is shorter, reducing the need for prolonged external support.

3. Time to Value

Phased Implementation:

• Gradual Benefits: Benefits are realized gradually as each module is implemented. This allows for continuous improvement and adjustments.
• Longer Project Duration: The complete transformation takes longer, which might delay the realization of the full benefits of ERPNext.

Big Bang Implementation:

• Immediate Benefits: All benefits are realized simultaneously once the system goes live, which can lead to quicker ROI.
• Shorter Project Duration: The entire implementation is completed in a shorter time frame, potentially accelerating business improvements.

4. Resource Allocation

Phased Implementation:

• Manageable Resource Use: Resources are allocated to each phase, making it easier to manage and avoid overwhelming the team.
• Continuous Engagement: Requires continuous engagement and commitment from key stakeholders and team members over a longer period.

Big Bang Implementation:

• Intensive Resource Use: Requires a significant amount of resources at once, which can strain the organization.
• Short-Term Commitment: The intensive nature requires a high level of engagement from stakeholders for a shorter period.

5. Change Management

Phased Implementation:

• Gradual Change: Allows for a more manageable change process, giving users time to adjust and become proficient with each module.
• Training and Support: Training can be tailored to each phase, providing focused and effective support to users.

Big Bang Implementation:

• Sudden Change: All changes occur simultaneously, which can be overwhelming for users.
• Intensive Training: Requires comprehensive training and support efforts before the go-live date to ensure users are prepared.

6. Business Disruption

Phased Implementation:

• Minimal Disruption: The impact on daily operations is minimized as only a portion of the system changes at any given time.
• Adaptability: Easier to adapt and make adjustments without significant disruption to the business.

Big Bang Implementation:

• Significant Disruption: The entire organization experiences a major change, which can disrupt business operations.
• One-Time Adjustment: Once the initial disruption is managed, the organization can settle into the new system without further interruptions.

7. Integration Challenges

Phased Implementation:

• Sequential Integration: Each module is integrated sequentially, allowing for thorough testing and adjustments as needed.
• Complex Dependencies: Managing dependencies between modules can be complex, requiring careful planning and coordination.

Big Bang Implementation:

• Simultaneous Integration: All modules are integrated at once, which can be challenging but ensures all parts of the system are immediately compatible.
• Immediate Resolution: Integration issues must be resolved quickly to avoid system-wide problems.

8. Customization and Flexibility

Phased Implementation:

• Incremental Customization: Customizations can be introduced gradually, allowing for flexibility and adjustments based on real-time feedback and evolving business needs.
• Iterative Refinement: Each phase offers an opportunity to refine and improve customizations before proceeding to the next phase.

Big Bang Implementation:

• Comprehensive Customization: Customizations need to be planned and implemented upfront, which requires thorough analysis and understanding of all business processes.
• Limited Flexibility: Changes post-implementation can be complex and costly, making it less flexible in accommodating new requirements.

9. Scalability and Future Growth

Phased Implementation:

• Scalable Approach: The phased approach allows the organization to scale the implementation based on growth and evolving needs, making it easier to manage future expansions.
• Future-Proofing: Each phase can be designed with future growth in mind, ensuring the system remains relevant as the business expands.

Big Bang Implementation:

• Immediate Scalability: The entire system is designed to handle current and future needs from the start, potentially reducing the need for significant changes in the near term.
• Potential Overload: If not properly scaled, the system might struggle to handle future growth, leading to potential performance issues.

10. Data Migration

Phased Implementation:

• Incremental Data Migration: Data migration can be handled in stages, reducing the risk of data loss or corruption and making it easier to validate and clean data.
• Focused Efforts: Each phase allows for focused efforts on migrating and validating data for specific modules, ensuring data integrity.

Big Bang Implementation:

• Comprehensive Data Migration: All data must be migrated at once, which can be complex and risky, requiring meticulous planning and execution.
• Higher Risk: The risk of data issues is higher as all data is moved simultaneously, necessitating robust backup and validation processes.

11. User Training and Acceptance

Phased Implementation:

• Gradual Training: Training can be conducted in phases, allowing users to gradually learn and adapt to the new system. This can improve user acceptance and proficiency.
• Continuous Feedback: Ongoing training and support can incorporate user feedback, enhancing the overall experience and effectiveness of the system.

Big Bang Implementation:

• Intensive Training: Comprehensive training programs must be conducted before the go-live date, which can be challenging and may overwhelm users.
• Rapid Acceptance: Users must quickly adapt to the new system, which can lead to resistance and potential issues with user adoption.

12. Project Management and Control

Phased Implementation:

• Controlled Execution: Each phase can be closely monitored and controlled, allowing for adjustments and refinements based on real-time feedback and performance.
• Manageable Scope: The scope of each phase is smaller and more manageable, reducing the complexity and improving project control.

Big Bang Implementation:

• Complex Management: Managing a large-scale implementation requires robust project management skills and tools to ensure all aspects are properly coordinated.
• Higher Stakes: The complexity and scale increase the stakes, making it crucial to have effective project management to avoid failures.

13. Regulatory Compliance

Phased Implementation:

• Easier Compliance: Ensuring compliance with industry regulations can be more manageable in phases, allowing for focused efforts on each module.
• Ongoing Adjustments: Compliance requirements can be adjusted and refined with each phase, ensuring ongoing adherence to regulations.

Big Bang Implementation:

• Comprehensive Compliance: All compliance requirements must be met upfront, which can be challenging but ensures the entire system is compliant from day one.
• Risk of Overlook: The complexity of implementing all modules at once can lead to oversight of certain compliance aspects.

14. Vendor and Stakeholder Management

Phased Implementation:

• Gradual Engagement: Vendors and stakeholders can be engaged in stages, allowing for better relationship management and clearer communication.
• Continuous Feedback: Ongoing interactions with vendors and stakeholders provide continuous feedback, improving overall satisfaction and project success.

Big Bang Implementation:

• Intensive Engagement: Requires comprehensive engagement with all vendors and stakeholders from the beginning, which can be challenging but ensures everyone is aligned.
• One-Time Effort: The need for intense coordination is concentrated in a shorter period, potentially leading to more efficient decision-making.

Conclusion

Choosing between Phased Implementation and Big Bang Implementation for ERPNext depends on your organization’s specific needs, resources, and risk tolerance.

• Phased Implementation is ideal for organizations seeking lower risk, manageable costs, gradual adaptation, and minimal disruption.
• Big Bang Implementation suits organizations that prefer immediate benefits, shorter project duration, intensive resource use, and a one-time adjustment period.

Careful consideration of these factors will help ensure a successful ERPNext implementation that aligns with your organizational goals and capabilities.

Installing a custom app on your running ERPNext instance that’s installed via Docker involves a few steps. Here’s a simplified guide on how to do it:

Note: Before installing any custom app, it’s always recommended to take a backup of your ERPNext instance, especially if it’s in a production environment. Also, thoroughly test the custom app to ensure it works as expected without causing any conflicts with existing functionality.

Access Your Docker Container: First, you need to access the Docker container where ERPNext is installed. You can do this using the docker exec command as shown below:

sudo docker exec -it <NAME> /bin/bash

Navigate to the Frappe Bench Directory: Ensure you are inside the bench directory. You can tell by checking whether you can run bench commands. If not, usually it’s located at /home/frappe/frappe-bench.

Clone the Custom App: If you already have the custom app code, you can clone it directly into the apps directory inside the Frappe Bench directory:

git clone <repository_url>

Install the Custom App: Install the custom app with the following command:

bench --site <site_name> install-app <app_name>

Migrate the site: When installation is completed, you will need to run the below migrate command to effect the changes to the database:

bench --site <site_name> migrate

Ensure you replace <site_name> and <app_name> with the name of your site and the name of your app respectively.

Restart the containers: Restart the containers to effect all the changes that have happened during the setup of the custom app.

Check Installation: After restarting the services, you can verify if the app is installed properly by accessing the ERPNext web interface and checking if the app appears in the module list.