Tell Composer to use Different PHP Version

Question

I've been stuck at this for a few days. I'm using 1and1 hosting, and they have their PHP set up a bit weird.

If I use just php composer.phar install, then I'm using PHP 4.4.6, which is horribly insufficient. However, I can run php5.5 composer.phar install, get a little bit further, but it still fails because somewhere along the line, PHP is called again, but it fails, as it's using 4.4.6.

Is there any way to tell Composer to use the php5.5 command? Has anyone successfully gotten Composer configured on 1and1 hosting?

I'm trying to get Laravel up and running (which uses Composer). I've been able to do it on my GoDaddy domain, but not 1and1.

The obvious remedy for this is to ditch 1and1 and get yourself a server to run it on. — John Corry, Sep 23 '15 at 23:18
I'd love to, but that's not currently an option. This is a server we're using at work, and I can't make that call. I'd love to ditch these guys and use GoDaddy, like I do for my personal domains. — Boom, Sep 24 '15 at 15:57

score 227 · Answer 1 · answered Sep 03 '18 at 09:35

227

Ubuntu 18.04 case ... this run for me.

/usr/bin/php7.1 /usr/local/bin/composer update

answered Sep 03 '18 at 09:35

Florin

5,781
2
20
30

2

I have use sudo /opt/lampp/bin/php /usr/bin/composer install and it works for me Thank you +1 – Bhavesh Prajapati Jun 17 '20 at 10:10
2

How is this fundamentally different from what the OP did and which did not work for him (php5.5 composer.phar install) because the commands invoked by Composer will still use the default PHP version? Test this yourself, add a "scripts" : "php-version": "php --version" and call e.g. /user/bin/php7.4 /usr/bin/composer php-version. – Sybille Peters Jun 27 '21 at 11:57
2

@SybillePeters, change your script to be e.g. "php-version": "/user/bin/php7.4 --version" I suppose you could configure your entire machine to use a specific version for `php` using `sudo update-alternatives --set php /usr/bin/php7.4` – Anony Mous Mar 02 '22 at 17:30
1

f**** crazy solution. Thank you – Shahid Karimi Sep 13 '22 at 08:50

score 202 · Answer 2 · edited Jun 21 '22 at 12:08

202

Maybe this can't solve exactly your issue but probably it will help others who comes here from web search.

Just run the command to add below code to your composer.json file to set different PHP version:

$ composer config platform.php 8.0.7

"config": {
    "platform": {
        "php": "8.0.7"
    }
}

edited Jun 21 '22 at 12:08

hakre

193,403
52
435
836

answered Feb 17 '19 at 19:41

Shaig Khaligli

4,955
5
22
32

44

I guess this isn't really the answer the OP was looking for, but it matches the title of the question very well and might be of great help to people arriving here from web search as it was to me. – Gregory Cosmo Haun Sep 10 '19 at 00:52
5

This won't run Composer with a different PHP version, but configure Composer to run the dependency resolver for another PHP version. IMHO, this does not answer the given question properly – Nico Haase Feb 02 '22 at 16:59
1

This is actually the only way you should do it especially when you have multiple projects running different PHP versions! Thank you! – George G Aug 03 '22 at 01:41
this does not work. I put that into my composer.json but composer -vvv about still shows using 8.1 – user6329530 Jun 01 '23 at 09:35

score 41 · Answer 3 · answered Jan 22 '18 at 09:46

41

On xubuntu I had php 7.2 as default. But needed to run composer with php 5.6.

So this worked for me:

php5.6 /usr/bin/composer

answered Jan 22 '18 at 09:46

Darius.V

737
1
13
29

1

Isn't this the same thing the OP was doing which failed for him because "but it still fails because somewhere along the line, PHP is called again, but it fails, as it's using 4.4.6."? – Sybille Peters Jun 27 '21 at 11:43
maybe no, because he done in not exactly same way – Darius.V Jul 11 '21 at 08:15

score 38 · Answer 4 · answered Jul 22 '20 at 16:09

38

If you just need to get composer to ignore the version requirements, you can bypass using:

composer install --ignore-platform-reqs

answered Jul 22 '20 at 16:09

Jon Gibbins

887
7
14

2

This won't run Composer with a different PHP version, but configure Composer to run the dependency resolver for another PHP version. IMHO, this does not answer the given question properly – Nico Haase Feb 02 '22 at 17:00
However, when I was having the problem that the OP described, this command was the solution for me. The description of my solution is accurate. – Jon Gibbins Jul 11 '22 at 09:55

score 38 · Answer 5 · answered Apr 23 '21 at 09:27

You always can use that way.

In project folder where you has composer.json file. Run the command

 php7.4 /usr/local/bin/composer install

or

php7.4 /usr/local/bin/composer update

where php7.4 your specific version can be(php7.0, php5.5, php7.3 etc...) where /usr/local/bin/composer path for system folder with composer

!!! you should have php7.4-cli

sudo apt-get install -y php7.4-cli

That way for linux/ubuntu user

Cheers ;-)

score 16 · Answer 6 · answered Jun 19 '19 at 03:14

composer is a PHP binary script and it's using Unix Shebang to define which interpreter for executing.

root@home:~# head /usr/local/bin/composer -n 5

#!/usr/bin/env php
<?php
/*
 * This file is part of Composer.
 *


/usr/bin/php7.1 /usr/local/bin/composer update

So if you're running composer without any specific option, it will use your PHP version at /usr/bin/env php (which is your default PHP)

We can have many versions of PHP inside your Linux and you can flexible use which PHP version for executing as you want like this way:

root@home:~# /usr/bin/php7.1 /usr/local/bin/composer update

Or just

root@home:~# php7.1 /usr/local/bin/composer
root@home:~# php7.2 /usr/local/bin/composer
root@home:~# php7.3 composer
...

To check & find all installed PHP packages, goto /usr/bin/

root@home:~# ls /usr/bin/ | grep php
php
php5.6
php7.1
php7.2
php7.3
php-config
php-config7.1
phpdbg
phpdbg5.6
phpize
phpize7.1

That's right, although it's not recommended to change the Shebang in the head of `composer`, you could break the original `composer.phar` file. — Ibrahim.H, Jan 03 '21 at 13:32

score 12 · Answer 7 · answered Nov 06 '18 at 23:06

I too have a shared hosting account on 1&1 (ionos) and here's what I have had to do:

if you login as the root ssh account, you can create a ~/.bash_profile and add

alias php="php7.1"
alias composer="php7.1 composer.phar"

to it so that you can now use the commands you would normally use and it just works. (put composer.phar in your project folder root)

Then, make sure your laravel composer.lock file from your dev machine gets up to your project folder on 1and1 and run

composer install

Using this tip from @tobymackenzie: on shared hosts you really should just run composer install (not update!) from a composer.lock file you created on your own machine. That way the memory usage remains very low.

I still had STDIN issues with artisan commands so make sure you change the .env file to

APP_ENV=local

because having it set to production throws infinite STDIN warnings as it waits for you to type yes. At least on my account it does.

Hope this helps somebody.

score 12 · Answer 8 · edited Mar 08 '21 at 20:23

12

In my case, Composer detected PHP version 7.2.6 but my actual PHP Version was 8.0.2 .So , I did the following steps and It was the solution for me.

Step 01:- Add below code to your composer.json file

"config": {
    "platform": {
        "php": "7.2.6"
    }
}

Step 02:- Then, run the below command.

C:\xampp\htdocs\your project name>composer update

edited Mar 08 '21 at 20:23

Yousha Aleayoub

4,532
4
53
64

answered Feb 12 '21 at 11:50

Lahiru Kumara

307
3
6

This won't run Composer with a different PHP version, but configure Composer to run the dependency resolver for another PHP version. IMHO, this does not answer the given question properly – Nico Haase Feb 02 '22 at 16:59
But this sometimes can help. For example, when you build your app in docker, and have another php version on local machine where develops – wapmorgan Mar 05 '22 at 09:59

score 11 · Answer 9 · edited Dec 22 '22 at 21:12

The existing answers partly do not answer the question, give suggestions that do not work or give bad advice.

The question stated:

However, I can run php5.5 composer.phar install, get a little bit further, but it still fails because somewhere along the line, PHP is called again, but it fails, as it's using 4.4.6.

Instead, I am here showing a way to test and verify the suggestions.

I wish I had a better answer myself but I am unsure what is the best solution. Personally I would go with a solution which make sure PHP is called with the correct version on the host (e.g. via an alias or setting the PHP environment correctly, running the entire operation inside a container or some other solution), regardless of Composer and add a platform php constraint.

If you don't run any scripts and just need the requirements to resolve the dependencies correctly config:platform:php would probably be your friend.

Let's say our default php version is 7.4 but our project requires 7.2.

Check your default PHP version

command line:

# shows version of default PHP
php --version
# show path of default PHP
which php

# show version of /usr/bin/env php
# /usr/bin/env php --version

Create a test script in your composer.json
```
"scripts": {
    "php-version": "php --version"

}
```
Now you can test what version of PHP is used for the commands Composer calls, e.g.
```
composer php-version
/usr/bin/php7.2 /usr/bin/composer php-version
```
In my case, both of these use my default php script (which is version 7.4). So, while the 7.2 version is used to run Composer, the scripts called by Composer use the default command (unless you use @php instead of php¹).
Now let's add the platform setting as suggested in some of the answers
```
"config": {
    "platform": {
       "php": "7.2.0"
    }
}
```
Does not change anything for the script execution:
```
/usr/bin/php7.2 /usr/bin/composer php-version

# result is still 7.4
```
Actually, what the platform option is important for is resolving the requirements, so you should add it (in your project composer.json). It just won't solve the above problem of composer using PHP with the correct version. See also Composer docs for platform.

If you use @php instead of php, then Composer uses the PHP_BINARY² path which is the php binary path that Composer tried to infer being executed with. See Executing PHP scripts. In this example commonly $(command -v php7.4) different to $(command -v php7.2), here $(command -v php).
PHP_BINARY is an environment variable Composer sets for its own environment (ref), similar to the predefined PHP_BINARY constant in PHP.

Thank you very much. This is very helpful for me especially into our transition to an arch-based linux platform due to php got updated to ver. 8 — leipzy, Jul 09 '22 at 03:30
To use composer PHP version in scripts: `"php-version": "@php --version"` -- mind the `@` in front of `php` in the script line. See [_Executing PHP scripts_](https://getcomposer.org/doc/articles/scripts.md#executing-php-scripts)- — hakre, Dec 22 '22 at 20:59

score 10 · Answer 10 · answered Feb 08 '19 at 06:36

10

Try this approach

ea-php72 /opt/cpanel/composer/bin/composer

answered Feb 08 '19 at 06:36

Erich García

1,648
21
30

Will this override the shebang at the start of the file? – it's a hire car baby Oct 06 '20 at 08:35

Ernest Elikem · Answer 11 · 2022-06-02T13:18:09.010

I had the same issue and this is how I was able to figure out how to run composer using a different PHP version on a shared hosting without breaking the system :)

Luckily, solving this issue with composer using different PHP version is dead simple.

Findings:

Default PHP was not run from /usr/local/bin or similar folder. Using the

which php

or

whereis php

would not give you the best answer.

Follow the short guide below:

First find the actual path to your composer binary itself. On my shared hosting server, it was at

/opt/cpanel/composer/bin/composer

I believe most hosting providers using cPanel would have such path to composer.

Next, create an alias to the PHP version you want to use. In my project, I needed php 7.4 or newer.

As mentioned earlier, the host was using cPanel and the actual default PHP version that the server uses is in the path /opt/cpanel/

You should see different versions of php in the /opt/cpanel/ (prefixed by ea-phpxx) for example, for php 7.4, it would be a folder called ea-php74 and for PHP 8.0, it would be a folder called ea-php80.

Now, be sure that php exists in a path similar to this:

/opt/cpanel/ea-php80/root/usr/bin

If you find php in the folder, then you can now alias it as folows:

alias php='/opt/cpanel/ea-php80/root/usr/bin/php'

Test that the alias is working by running

php --version

and check the php version as shown in the screenshot below:

Now, run composer as normal. For example

 php /opt/cpanel/composer/bin/composer update
 php /opt/cpanel/composer/bin/composer install
 php /opt/cpanel/composer/bin/composer install

Remember how we found the composer binary at /opt/cpanel/composer/bin/composer. If this does not match the path to the compser binary on your server, use the appropriate one.

I hope this helps. Happy Coding!

Great answer, this do the trick for me – Felipe Castillo Dec 06 '22 at 17:50 — Felipe Castillo, Dec 06 '22 at 17:50

bernie · Answer 12 · 2015-09-24T16:15:07.480

5

You could change your PATH to override the php version.

PATH="/home/user/bin:$PATH"

In /home/user/bin (or any other directory really) make a symlink named php to the php5 binary.

Another option, use a shell alias:

alias php="/path/to/php5"

edited Sep 24 '15 at 16:15

answered Sep 24 '15 at 02:39

bernie

9,820
5
62
92

I don't have write access to the home directory. 1and1 has littered this domain with red tape. – Boom Sep 24 '15 at 15:56
1

beware, this answer may break your system. – Pedro Lobito May 17 '20 at 00:03
Hmm changing PATH does work, but using alias does not for me. – Adam Fowler Aug 11 '22 at 16:43

score 4 · Answer 13 · answered Jan 14 '21 at 13:02

4

I'm on a Hostgator shared account, the following worked for me:

First, find out where your desired version of PHP lives (you can start typing ea-php and hit TAB to list all available executables starting with ea-php):

which ea-php73
```
/usr/local/bin/ea-php73
```
Then, find out where composer lives:

which composer
```
/opt/cpanel/composer/bin/composer
```
Then use those to run your composer command:

/usr/local/bin/ea-php73 /opt/cpanel/composer/bin/composer install

answered Jan 14 '21 at 13:02

Magnus

17,157
19
104
189

just in case someone wants to verify if it works or not, try this. https://stackoverflow.com/a/56379908/2190689 – ssi-anik Mar 07 '22 at 15:06

score 4 · Answer 14 · answered Jun 13 '21 at 23:23

For people using Plesk, you need the different pieces:

Get the PHP version required from /opt/plesk/php/<version/bin/php, eg /opt/plesk/php/7.4/bin/php
Get the real path of composer since /usr/local/bin/composer is a custom Plesk script by vieweing the script contents ( cat /usr/local/bin/composer ). In my case, it was /usr/local/psa/var/modules/composer/composer.phar
Put it all together:

# /opt/plesk/php/7.4/bin/php /usr/local/psa/var/modules/composer/composer.phar install

... or to make it simpler, just create a new file ( I like composer74 ) in /usr/local/bin:

cat > /usr/local/bin/composer74 to create the file
paste the following:

#!/bin/bash
/opt/plesk/php/7.4/bin/php /usr/local/psa/var/modules/composer/composer.phar

insto the terminal

Hit CTRL+D to save the file
chmod +x /usr/local/bin/composer74 to make it executable
Use it anywhere:

# composer74 install

Added "$@" at the end, like so: /opt/plesk/php/7.4/bin/php /usr/local/psa/var/modules/composer/composer.phar "$@" — Boyan Georgiev, Nov 12 '21 at 09:55

score 3 · Answer 15 · answered Jul 02 '19 at 13:56

Know this question is a bit old... but if you pull down composer into your app root:

https://getcomposer.org/download/

Instead of relying on global composer, then you can run:

php56 composer.phar {your command}

or I believe newer homstead versions would be like:

php7.1 composer.phar {your command}

https://laracasts.com/discuss/channels/laravel/run-composer-commands-with-different-php-versions

Vishal Thakur · Answer 16 · 2021-01-29T07:25:10.280

3

Ubuntu 18.04 case ... this works for me. Here, Composer picks the required PHP version automatically.

/opt/lampp/bin/php /usr/bin/composer install

OR

 /opt/lampp/bin/php /usr/bin/composer update

edited Jan 29 '21 at 07:25

answered Jul 10 '20 at 19:49

Vishal Thakur

1,564
16
25

score 3 · Answer 17 · answered Oct 25 '22 at 14:02

3

While trying to install a Laravel application on my SiteGround shared hosting using SSH, I had to specify the adequate PHP bin constant prior to executing composer :

PHP_BIN=php81 composer install

Other solutions here would not work.

answered Oct 25 '22 at 14:02

wlarcheveque

894
1
10
28

score 2 · Answer 18 · answered Feb 04 '16 at 19:08

php5.5 composer.phar install fails because your composer.json is telling it to run php and not php5.5, edit the file composer.json replace the php scripts references to php5.5. Example:

From:

"post-root-package-install": [
    "php -r \"copy('.env.example', '.env');\""
],

To:

"post-root-package-install": [
    "php5.5 -r \"copy('.env.example', '.env');\""
],

Even when doing this, 1and1 has a memory limit for scripts execution so php5.5 composer.phar install won't fail but it won't complete its execution either. You can still run the scripts post install manually.

I have deployed Laravel webapps to 1and1 without commit vendor directory, following this guide: Deploy Laravel Webapp to 1and1

I don't have a `post-root`package-install` field. Should I add one? — Boom, Feb 04 '16 at 21:22
Is not needed, you can achieve same effect running `cp .env.example .env`, it just copies contents of `.env.example` to a new file called `.env` — Carlo Espino, Feb 04 '16 at 21:47

harri · Answer 19 · 2021-06-02T08:59:49.067

I had no luck with any of above answers, I had auto scripts in composer.json so just ignoring or faking platforms just caused failed scripts etc. Setting php version in command just didn't work!

I did notice however that although running which php and php -v returned correct version which /usr/bin/env php returned the problematic version of php that composer was using. So found a very good answer here and outlined below:

Issue:

/usr/bin/env php looks for an executable named php in the current $PATH; it pays no attention to aliases, shell functions, etc. If you want it to execute php v5.3, you have to put that version in a directory under the name php, and put that directory in your PATH somewhere before the directory that contains the problematic version.

Fix:

Create new php executable folder like below with your specific php executable linked inside:

mkdir /usr/local/bin/php-overrides
ln -s /usr/local/bin/php7 /usr/local/bin/php-overrides/php

Add below to your ~/.bash_profile (or other appropriate startup script):

PATH="/usr/local/bin/php-overrides:$PATH"

https://serverfault.com/questions/579956/alias-doesnt-work-in-script-with-usr-bin-env-php

This is the correct answer. As [Sybille outlined with the example](https://stackoverflow.com/a/68151169/3894752) the `platform` setting does *not change* any local PHP paths. Instead Composer will use this value to _fetch dependencies_ matching this version only. No more, they still run with the current PHP version. Only a change of the `$PATH` variable will change the PHP version used to run subscripts. — pixelbrackets, Aug 06 '21 at 14:48
One more comment - there are several tools available to change the PHP version via the `$PATH` env variable. One example is https://github.com/webit-de/php-version-pickup. It picks up the version from a `.php-version` file and continues to use it in the current shell session, also for all subprocesses like the ones initiated by Composer. — pixelbrackets, Apr 04 '22 at 14:22

score 2 · Answer 20 · edited Jul 08 '21 at 19:25

2

There are two ways to do it.

Tell the composer to ignore the platform requirements while running the command in the terminal.

composer update --ignore-platform-reqs

Tell the composer to ignore the platform requirements in the composer.json file in the project root directory.

"config": {  
    "platform-check": false, 
},

edited Jul 08 '21 at 19:25

Karl Hill

12,937
5
58
95

answered Jul 08 '21 at 17:45

ov_rezoy

51
1
6

This won't run Composer with a different PHP version, but configure Composer to run the dependency resolver for another PHP version. IMHO, this does not answer the given question properly – Nico Haase Feb 02 '22 at 16:59

score 2 · Answer 21 · answered Jul 11 '21 at 18:55

2

We can tell Composer, what version of PHP we are supporting with our app by using the platform configuration in our composer.json file by adding the following configuration,

{
"config": {
    "platform": {
        "php": "5.5"
    }
},
"require": {
    ...
 }
}

Or from the command-line

composer config platform.php 5.5

answered Jul 11 '21 at 18:55

Prasad Gayan

1,424
17
26

1

Legend, just what I needed :) – lky Oct 07 '21 at 14:52
1

This won't run Composer with a different PHP version, but configure Composer to run the dependency resolver for another PHP version. IMHO, this does not answer the given question properly – Nico Haase Feb 02 '22 at 16:59

score 2 · Answer 22 · answered Dec 14 '21 at 03:43

2

i have a method to slove this problem.


    export PATH=/usr/local/Cellar/php/8.0.12/bin:$PATH && composer -vvv

Temporarily change environment variables and use composer

answered Dec 14 '21 at 03:43

Cao Vison

47
5

Despite being down voted, this did work for me :) Fresh Rocky linux install with composer from remi repo, composer kept trying to use the core system PHP 7.2 and not my PHP 7.4 from remi required by composer.json packages. – Neek Jun 09 '22 at 07:28
This is best when you need to temporary switch. – Harry Oct 02 '22 at 15:25

score 2 · Answer 23 · answered Mar 11 '22 at 21:41

With PHP 8 and 8.1 coming out, I have to work with a couple of versions regularly in the CLI, and the best way I found to do this was to create an alias.

Assuming you installed using brew, or already know where your version of PHP is.

Add the following to your bash profile.

alias php7='/usr/local/opt/php@7.4/bin/php'
alias php8='/usr/local/opt/php@8.0/bin/php'

If you want you can install PHP 8.1 as well with brew install php@8.1 and add another alias.

This will allow you to run php8 composer, you can do a quick test by creating an index.php file and adding phpinfo() to it.

php7 index.php | grep "PHP Version"
php8 index.php | grep "PHP Version"

score 0 · Answer 24 · answered Jan 27 '21 at 01:50

0

Must add in two places in your composer.json file to set different php version:

"config": {
    "platform": {
        "php": "7.4"
    }
}

"require": {
    "php": "^7.4",
}

answered Jan 27 '21 at 01:50

Bira

4,531
2
27
42

1

This won't run Composer with a different PHP version, but configure Composer to run the dependency resolver for another PHP version. IMHO, this does not answer the given question properly – Nico Haase Feb 02 '22 at 16:59

score -1 · Answer 25 · answered Dec 28 '15 at 13:43

-1

You could try and copy the php and php-config files into /usr/local/bin instead. That path has a higher order of precedence and should override the /usr/bin folder without needing to disable SIP. That is what I did.

answered Dec 28 '15 at 13:43

Dave

9

Please share more details. What do you mean by "SIP"? Also, on shared hosting (as given in the question), you cannot edit anything in `/usr/local/bin` – Nico Haase Feb 02 '22 at 17:01

Bitpatroon · Answer 26 · 2022-12-01T13:13:27.380

On AlmaLinux with php74 my default PHP version, php81 installed to /usr/bin/php81 and composer in location /usr/bin/composer, the following works one time: running composer using php81.

/usr/bin/php81 /usr/bin/composer install

Composer flags can be added as following:

/usr/bin/php81 /usr/bin/composer install --no-dev --no-interaction --ignore-platform-reqs

Notice these commands need to be executed from you working folder.

Tell Composer to use Different PHP Version

26 Answers26

Linked

Related