How To Install Magento 2.3 3

This guide will innovate you to Composer and demonstrate its applications with Magento 2 (now known as Magento Commerce/Magento Open up Source), with a little bit of Git thrown in. You'll develop have a solid understanding of how to install Magento two via Composer, know what Composer can offer for other projects, and see how it can be used as a base to work with Git that mimics other modern PHP frameworks.

Delight note, this guide was first published alee of Magento 2 general availability and therefore can be subject subject to amendments.

ane. What is Composer?

How many times accept you started a new project by visiting the project's website and downloading a TAR file or .zip archive? And how many times accept y'all had to revisit that site when an update is needed?

The more technically astute readers may have mastered the commands Wget or whorl. This in one case (or perhaps a few times during a project) this ritual is allowed and we use the same process every fourth dimension we want a new dependency.

In the Magento globe this is then extracted into the lib folder. Yet how many times have yous installed an extra package merely to be presented with the fatal screen of death indicating a missing package or class not establish? Maybe you then have to turn to PEAR or Google to download and extract more packages in the hope that nosotros accept concurred the software dependency tree for this package?

Although this may seem a convoluted scenario, as the world of software has evolved, so the number of dependencies and available packages has increased. Therefore this scenario cannot be avoided forever.

To solve this problem Jordi Boggiano began developing Composer, a tool for dependency management in PHP. It allows yous to declare the libraries your project depends on, and volition manage (install/update) them for you.

Composer may seem similar an answer to all your prayers, merely it does nowadays new questions such every bit:

• How tin I fit Composer into my workflow?
• How will this not add more fourth dimension to my build process?

I had similar questions when I kickoff began using Composer, merely before long I realised the endless hours saved in resolving dependency issues more than than made up for the time spent introducing information technology to development processes.

Composer ensures all of our development team works from the verbal version of the modules we require for our work, and is a valuable tool for any PHP engineer.

Not merely tin Composer handle our dependencies, but it can besides plant a base project to piece of work from.

If you don't take Composer installed, head over tohttp://getcomposer.org and follow the relevant starter guide your operating system. In one case installed, run the following:

2. Magento and Composer

          composer create-project —stability=beta —no-install magento /project-community-edition Magento        

Let'southward interruption this down step by step. Outset we call a Composer command for 'create projection'. This creates a new folder and prepares us for a project setup with Magento 2 (now known as Magento Commerce) within it.

Stability is a fiddling easier to grasp. Composer knows the stability of packages and we can utiliseAlpha,Beta orStable types of packages. For the purpose of this guide we'll use the Magento 2 Beta. Up adjacent we pass an statement into Composer for

          –no-install        

This tells Composer to only download the files that come from the project repository, and practice zero else. Composer could await at the composer.json file in the new projection and start installing all dependencies from there. Although we want to add more packages later, we don't want to become through the install process nonetheless. This activeness defers the actual Composer install until information technology is required. Now for the main event:

          magento/projection-communityedition        

is the packet we want to download. This can be considered a placeholder for the actual Magento 2 project. Ameliorate still, this repository acts every bit the pattern for composing a full Magento 2 project and it's mutual for frameworks to offer this 'skeleton' arroyo to kickoff projects. The Magento two squad recommend this approach over installing the Magento/ Magento2 repository via a Git clone.

Last but not least, you will need to specify a folder name that nosotros want the project to be installed with. In this case we will have a binder called Magento with Magento ii installed within it. At the end of this process, we take a Magento 2 project installed via Composer, just what are some immediate benefits?

For starters, an upgrade to a new Beta version is much more straightforward. Remember the days you dreaded a Magento i upgrade landing on your desk? Dread no more than; simply open the composer.json file and find the version number specified adjacent to the Magento 2 package. And then, but change this to the version you lot demand. Salvage the file and run a Composer update.

Hey presto, the source files have been updated to the specified version of Magento. Granted, at that place is more than work to do, just that should merely be a unproblematic php bin/magento setup:upgrade, but this is a topic for some other pocket guide.

iii. Magento, Composer and Git

Information technology is practiced exercise to use a source control management (SCM) tool to manage our projects. Other SCMs are available, but for the purpose of this pocket guide we will use Git.

Let's begin past adding some files. Magento ii (now known as Magento Commerce/Magento Open Source) has shipped with a default .gitignore file. However this has been offered to cover the most general of cases. If nosotros wanted to utilise this file to ignore parts of the project it would, but nosotros would likewise nonetheless get a lot of Magento two endemic code added to our repository. So is this bad? Allow'due south expect at the options.

Information technology isn't the end of the globe for us to add Magento ii to the repository – we accept done the aforementioned for Drupal, WordPress and Magento 1 sites for example. We can still deploy a project with the source files from the framework added to it. The 1 thing to annotation here is that in one case we accept identified that our version of Magento 2 needs updating, we would need to modify the composer.json version constraint, run composer update, and commit all the files that have changed. And so you would get:

          composer.json composer.lock … All of the Magento files that have inverse        

In my opinion, this tin can bloat the project's history with what could be a mass update of files. As it involves managing the dependencies of the projection, this approach also does the job of Composer. Magento ii is just a dependency of our project and is not the project itself. Proceed that in mind.

By including Magento 2 as a dependency inside the Composer file it creates lots more opportunities such as when we are creating new extensions we tin tell our continuous integration server to run the test suite against different versions of Magento 2 just by modifying the version of the dependency in the composer.json file.

All the same, we are using Composer to install our framework, and then if Composer has the functionality to manage the dependencies down to the verbal releases / version, why practice we need to also rely on Git pinning our version for u.s.?

We know that if we change a core file and want to revert it back to its initial state we can easily run a Composer update. If nosotros are lucky then Composer will accept maintained a buried copy of this version so it doesn't even need to hit the internet to retrieve a copy.

Author's disclaimer: There is nothing fundamentally incorrect with the get-go approach. I have personally used this method and probably nevertheless would if there was no other pick. But the second betoken shows a leaner / different method to managing our dependencies and managing our workflows with Git and Composer.

Have I sold you on the Composer dream yet? If so I can hear you banging on the computer screen in apprehension of what to exercise next. Well here we go: In your preferred editor of option open up up the projection's

          .gitignore        

A quick annotation on Git Ignores

Every bit a quick point of reference if you see a file in the project that looks like .gitignore it means that when Git runs, the projection volition match the file or folder contained in this list and ensure they are never part of the project'south repository.

In Magento 2 (Magento Commerce/Magento Open Source), by default we are looking to exclude env.php and config.php amid many more than files and folders. These ii are easy to highlight every bit they are both auto-generated files that could be different per user and will exist dissimilar per server (database passwords and username). It is likewise worth noting that we should never commit credentials to the repository for security reasons.

Returning to our editor with the open up .gitignore file you lot should encounter something that resembles the post-obit:

          /.buildpath  /.enshroud  /.metadata  /.project  /.settings  atlassian  /nbproject  /sitemap  /.idea  ...        

We want to ensure that none of the Magento 2 created files are added into the projection. Nosotros do this by adding the paths to this file:

                      /.htaccess  /.htaccess.sample  /.php_cs  /.travis.yml  /CHANGELOG.md  /CONTRIBUTING.dr.  /CONTRIBUTOR_LICENSE_  AGREEMENT.html  /COPYING.txt  /Gruntfile.js  /LICENSE*.txt  /app/code/Magento  /app/design/adminhtml/Magento  /app/blueprint/doc  /app/design/frontend/Magento  /app/etc  /app/i18n  /app/.  /bin/  /dev/  /alphabetize.php  /lib/  /nginx.conf.sample  /packet.json  /php.ini.sample  /pub/  /setup/  /update/  /var/  /vendor/        

4. Using Git

For anyone just starting out with Git I recommend reading a decent starter guide such as this before reading this section.

At present nosotros are in a position to configure this folder to get a local Git repository and we tin can add the files / changes to it then we tin can run into what is now part of the repository. From your last run the post-obit commands:

          git init –                  

This initialises the project equally a git repository (a special .git binder is added likewise as a local database to store and summate changes

                      git status        

– Running this command should allow you to run across all the changes that tin can be either:

                      Staged ( S )  Added / Removed ( A / R )  Not staged ( ? )        

          git add        

– Running this command takes all of the files that are not staged (not currently part of the Git repository) and adds them to the index.

          git commit -thou "Hello World"        

– This is the command that enforced the commit. We are committing the staged files into the repository and ensuring that whatsoever changes in these files and to these files volition be tracked. Now the following command is optional.
If you use a service similar GitHub, y'all want to make certain your changes are in that service. Nosotros need to button and pull changes to and from stores of the project:

          git push remote service proper noun remote service branch                  

We did a lot of things in a short space of fourth dimension and then let's clarify what it is we have washed and accomplished.

We started by initialising an empty git repository in the binder where we used Composer to create a Magento 2 project. Nosotros then instructed Git via the

          .gitignore                  

file to ignore all of the folders that will contain only Magento code and never our own

          (app/code/Magento, app/design/Magento)        

We did this considering Composer is able to repeatedly download the aforementioned version of Magento based on our composer.json file.

Finally, we went through the workflow of seeing what changes have been made to the repository

          (git status)        

 , nosotros staged the files git add, and finally committed them into the repository history with a nice big

          git commit.                  

For those feeling brave we also pushed to a remote service like GitHub.

five. Magento upgrades

Imagine the scene. You walk into the part ready to slowly become into gear, when the commencement support ticket of the week lands on your desk.

Your most of import client, "Luma", wants to upgrade its Magento 2 shop from one.0.0-beta to the new and improved 1.1.0 version. Your middle sinks as you remember the last upgrade of Magento you did. Downloading files directly from Magento, copy-and-pasting them over, the database backups, the setup scripts – the list goes on.

Author's note: The scenario may have been enhanced for dramatic effect.

However, Magento 2 now uses Composer to manage dependencies, including Magento two. Magento 2 is now included in the composer.json file and so we can install specific versions of the core platform. One of the future goals of the project is to decouple every module and so we can exist more granular with what versions of modules we are installing.

Open upwardcomposer.json in your editor and observe the line that references"magento/production-communityedition": "1.0.0-beta".

Edit the dependency to be i.i.0-beta, save the file, and run the composer update. Composer will whirl into action:reading remote repository…. getting data…. upgrading Magento….

Composer completes the upgrade cleanly without result, just you know that,when moving between versions of Magento, it'southward best practice  to run thesetup:upgrade script.

Runphp bin/magento setup: upgrade and ensure it reports no errors. Looking back at the terminal application of your choice yous can run composer status to meet that the only two modified files arecomposer.json andcomposer.lock. You will also see a change for acomposer.lockfile, but what does this refer to?

So far in this guide we have discussed how Composer can manage dependencies and even pin usa to a specific release or version. It does this by maintaining a file calledcomposer.lock, which references the verbal commit that relates to the checked out version of the dependency. This means that no matter how many times we delete vendor and all other files, based on the versions that are set in the composer.lock we will always get the exact same version of the dependency. Ifcomposer.json says the dependency is version one.0.0 and so that is what we will get time and time once more. There are ways that this can be changed – mainly past homo fault or past calculation not-concrete version numbers in thecomposer. json file. One indicate to note is that when we practise go into production we should only be running a Composer install to ensure nosotros get the verbal aforementioned versions of the dependencies as nosotros have while working locally. If we ran Composer update there is a danger that we update the dependencies and innovate uncertainties.

6. Composer and versioning

Now is a good time to explicate how versioning works in Composer.

So far in this guide we have referenced verbal version match. For example,

          one.0.0-beta        

However, there are alternatives that can be used:

• ~ can be used to indicate nosotros want the well-nigh recent all-time friction match based on all dependencies
• = can be used to indicate we want whatsoever version that is greater than or equal to what we specify
• =1 is all packages greater than or equal to 1. 1.0, 1.1, one.2, 2 etc.
• <= handles less than or equal to. E.g. 1.1.0 would become ane.0.0 etc.
• =X | <= Y ranges can as well be used, but with the raft of other options this is considered far from all-time practice.
• ^Ten The caret operator has been introduced recently and acts similarly to how the tilde operator works. Withal, this fourth dimension it understands Semver and will not bring in any non-breaking version changes. If y'all are writing a library then this is considered the operator to utilise.

seven. Composer and stability

Knowing near Composer and some of the inner implementations is a must-have for software engineers these days.

Where we would previously accept reinvented the wheel writing our ain libraries for date and time, for case, nosotros tin can now use the community to increase our productivity and but write code that meets our business domain.

As well, knowing well-nigh how versioning works will ensure nosotros will non get any version surprises when we go live or when working in a team. Knowing most the different version constraints can permit us to pull in different versions of libraries depending on our squad needs.

Equally well as specifying versioning for our code and dependencies, we can also specify stability. The mutual terms of stability are Blastoff, Beta and Stable.

What is Alpha?
Alpha is considered to be bleeding-edge and very unstable software that is nether active evolution. Breaking changes can exist introduced during Blastoff development, so it'due south non recommended for production use.

What is Beta?
Beta refers to software that has had some work done to increase its stability and is ready for some users to use it. Anyone using Beta code should be aware that, different Alpha code backwards compatible (BC), changes are not immune to be introduced, although in some instances they do sneak through. Beta software is notwithstanding not recommended for production employ, but can be used ready for a release and on non-critical implementations.

What is Stable?
So nosotros know that Blastoff should not exist used in product, and Beta should not always exist used in production. Stable is well, stable. It has no BC breaks, should follow Semver for its versioning on major minor and bug fixing, and tin be used in product.

Using stability in a Composer project
You tin can specify what state of software nosotros want to install by calculation the post-obit to our composer.json file:

          minimum-stability: dev, alpha, beta, RC, and stable                  

Now, when the Composer update / install runs it will respect the projection's minimum stability when installing packages, and merely install those that match this requirement. If there are no packages that match this requirement, you lot will receive a Composer error informing you that nothing tin be installed with this level of stability.

Specify packet level stability
Project level stability is swell, but sometimes nosotros want to exist more selective and merely install certain packages that are either Alpha, Beta etc. To do this we can specify the stability under the crave section of composer. "crave":

          "monolog/monolog": "one.0.@dev"        

Pretty simple, but do remember that if you lot are using Alpha or Beta dependencies within your project and so you may come across bugs with the bundle, every bit it is all the same evolving and not production-set.

eight. Finding packages

So far we have seen how easy information technology is to install dependencies into our project, but what nosotros take not covered is how to find all of these packages.

The kind folk at Composer accept provided us with Packagist. Think of Packagist as the Google of PHP project dependencies; information technology is an indispensable tool.

What could be more simple? We know that we want to add some level of logging to our arrangement so searches for log generates the following results:

Information technology gets even better. The results show a basic description, dependencies, number of downloads, and ratings from the Packagist community, and links to Git repositories.Packagist also provides the information required to add to the Composer file or the necessary command line:

          "psr/log"        

In the 'How to create a Control Line module' guide nosotros will cover how to install and use packages from Packagist, and how they are autoloaded using the composer and Magento ii (now known as Magento Commerce) autoloader. If yous want to learn more nearly how to use a package, the Composer website has a really good beginner's guide that will help you go started.

9. Conclusion

This brings us to the end of this adventure into Composer, Git and Magento 2( at present known as Magento Commerce/Magento Open Source). I hope that after reading this guide you:

• Feel confident to install Magento 2 via the command line
• Know the nuts of Composer
• Are happy with versioning
• Tin find tertiary party packages that can be used within Magento 2
• Understand the importance and office of SCM

Source: https://inviqa.com/blog/magento-2-tutorial-how-install-composer

Posted by: hookyousin45.blogspot.com

Share this post