Paigaldamine

phpMyAdmin ei rakenda erilisi turvameetrmeid MySQL andmebaasiserverile. Süsteemiadministraatori ülesanne on tagada korrektsed õigused MySQL andmebaasides. Selleks võib kasutada phpMyAdmin’i lehekülge Kasutajad.

Linuxi distributsioonid

phpMyAdmin’i leiab enamikust Linuxi distributsioonidest. Võimaluse korral on soovitatav kasutada distributsiooni pakette, sest need pakuvad tavaliselt paremat sidumist su distributsiooniga ja turvauuendused saab automaatselt kätte oma distributsioonist.

Debian and Ubuntu

Enamikus Debiani ja Ubuntu versioonides on phpMyAdmin’i pakett saadaval, kuid arvesta sellega, et seadistusi hoitakse kataloogis /etc/phpmyadmin ja seadistused võivad erineda ametlikust phpMyAdmin’i dokumendatsioonist. Täpsemalt on muudetud:

More specific details about installing Debian or Ubuntu packages are available in our wiki.

Vaata ka

Lisainfot leiad failist README.Debian (Debiani pakett paigaldab ta kui /usr/share/doc/phpmyadmin/README.Debian).

OpenSUSE

OpenSUSE tuleb phpMyAdmin’ga: lihtsalt paigalda paketid teenusest openSUSE Build Service.

Gentoo

Gentoo pakub phpMyAdmin’i paketi nii peaaegu standard seadistustega kui ka nn. webapp-config seadistuses. Paigaldamiseks käivita emerge dev-db/phpmyadmin.

Mandriva

Mandriva pakub phpMyAdmin’i paketti oma contrib harus; selle saab paigaldada tavameetodil Juhtimiskeskuse kaudu.

Fedora

Fedora sisaldab phpMyAdmin paketi, kui arvesta sellega, et seadistused asuvad kataloogis /etc/phpMyAdmin/ ja võivad erineda phpMyAdmin’i dokumentatsioonist.

Red Hat Enterprise Linux

Red Hat Enterprise Linux ise ja selle tuletised nagu CentOS ei sisalda phpMyAdmin’i paketti, kuid Fedora juhitud repositoorium Extra Packages for Enterprise Linux (EPEL) sisaldab. Repositooriumi kasutamisel arvesta sellega, et seadistused asuvad kataloogis /etc/phpMyAdmin/ ja võivad erineda phpMyAdmin’i dokumentatsioonist.

Paigaldamine Windowsile

Lihtsaim viis saada phpMyAdmin Windowsile on kasutada kolmandate osapoolte tooteid, milles on nii phpMyAdmin kui ka andmebaas ja veebiserver. Üks selline on XAMPP.

Selliseid pakette leiad rohkem Wikipeediast.

Paigaldamine Git’st

In order to install from Git, you’ll need a few supporting applications:

Sa saad kloonida phpMyAdmini uusima lähtekoodi aadressilt https://github.com/phpmyadmin/phpmyadmin.git:

git clone https://github.com/phpmyadmin/phpmyadmin.git

Lisaks pead paigaldama Composeriga järgnevad moodulid:

composer update

Kui sa arendada ei kavatse, siis saad arendusvahendite paigalduse jätta vahele käivitades:

composer update --no-dev

Finally, you’ll need to use Yarn to install some JavaScript dependencies:

yarn install --production

Paigaldamine Composeri abil

Sa saad paigaldada phpMyAdmini töövahendi Composer abil. Alates väljalaskest 4.7.0 on kõik väljalasked peegeldatud vaikimisi hoidlasse Packagist.

Märkus

The content of the Composer repository is automatically generated separately from the releases, so the content doesn’t have to be 100% same as when you download the tarball. There should be no functional differences though.

To install phpMyAdmin simply run:

composer create-project phpmyadmin/phpmyadmin

Alternatively you can use our own composer repository, which contains the release tarballs and is available at <https://www.phpmyadmin.net/packages.json>:

composer create-project phpmyadmin/phpmyadmin --repository-url=https://www.phpmyadmin.net/packages.json --no-dev

Paigaldamine Dockeri abil

phpMyAdminiga on kaasas Docker official image (ametlik tõmmis Dockerile), mille saad vähese vaevaga paigaldada. Sa saad selle alla laadida kasutades:

docker pull phpmyadmin

The phpMyAdmin server will listen on port 80. It supports several ways of configuring the link to the database server, either by Docker’s link feature by linking your database container to db for phpMyAdmin (by specifying --link your_db_host:db) or by environment variables (in this case it’s up to you to set up networking in Docker to allow the phpMyAdmin container to access the database container over the network).

Docker environment variables

You can configure several phpMyAdmin features using environment variables:

PMA_ARBITRARY

Lubab sul meldimisvormi sisestada andmebaasi serveri hosti nime.

PMA_HOST

Kasutatava andmebaasi serveri hostinimi või IP aadress.

PMA_HOSTS

Kasutatavate andmebaasi serverite hostinimed või IP aadressid (komaga eraldatud).

Märkus

Used only if PMA_HOST is empty.

PMA_VERBOSE

Andmebaasi serveri sõnaohter nimi.

PMA_VERBOSES

Andmebaasi serverite sõnaohtrad nimed (komaga eraldatud).

Märkus

Used only if PMA_VERBOSE is empty.

PMA_USER

Kasutaja Autentimisrežiimi seaded töötamiseks.

PMA_PASSWORD

Salasõna Autentimisrežiimi seaded töötamiseks.

PMA_PORT

Port, mida andmebaasi serveri kasutab.

PMA_PORTS

Pordid, mida andmebaasi server kasutab (komadega eraldatud).

Märkus

Used only if PMA_PORT is empty.

PMA_ABSOLUTE_URI

The fully-qualified path (https://pma.example.net/) where the reverse proxy makes phpMyAdmin available.

HIDE_PHP_VERSION

If defined, this option will hide the PHP version (expose_php = Off). Set to any value (such as HIDE_PHP_VERSION=true).

UPLOAD_LIMIT

If set, this option will override the default value for apache and php-fpm (this will change upload_max_filesize and post_max_size values).

Märkus

Format as [0-9+](K,M,G) default value is 2048K

PMA_CONFIG_BASE64

If set, this option will override the default config.inc.php with the base64 decoded contents of the variable.

PMA_USER_CONFIG_BASE64

If set, this option will override the default config.user.inc.php with the base64 decoded contents of the variable.

By default, Küpsistega autentimisrežiim is used, but if PMA_USER and PMA_PASSWORD are set, it is switched to Autentimisrežiimi seaded.

Märkus

The credentials you need to log in are stored in the MySQL server, in case of Docker image, there are various ways to set it (for example MYSQL_ROOT_PASSWORD when starting the MySQL container). Please check documentation for MariaDB container or MySQL container.

Konfiguratsiooni kohandamine

Additionally configuration can be tweaked by /etc/phpmyadmin/config.user.inc.php. If this file exists, it will be loaded after configuration is generated from above environment variables, so you can override any configuration variable. This configuration can be added as a volume when invoking docker using -v /some/local/directory/config.user.inc.php:/etc/phpmyadmin/config.user.inc.php parameters.

Note that the supplied configuration file is applied after Docker environment variables, but you can override any of the values.

For example to change the default behavior of CSV export you can use the following configuration file:

<?php
$cfg['Export']['csv_columns'] = true;

You can also use it to define server configuration instead of using the environment variables listed in Docker environment variables:

<?php
/* Override Servers array */
$cfg['Servers'] = [
    1 => [
        'auth_type' => 'cookie',
        'host' => 'mydb1',
        'port' => 3306,
        'verbose' => 'Verbose name 1',
    ],
    2 => [
        'auth_type' => 'cookie',
        'host' => 'mydb2',
        'port' => 3306,
        'verbose' => 'Verbose name 2',
    ],
];

Vaata ka

See Seadistamine for detailed description of configuration options.

Dockeri köited

You can use the following volumes to customize image behavior:

/etc/phpmyadmin/config.user.inc.php

Can be used for additional settings, see the previous chapter for more details.

/sessions/

Directory where PHP sessions are stored. You might want to share this for example when using Sisselogimise autentimisrežiim.

/www/themes/

Directory where phpMyAdmin looks for themes. By default only those shipped with phpMyAdmin are included, but you can include additional phpMyAdmin themes (see Kohandatud teemad) by using Docker volumes.

Dockeri näited

To connect phpMyAdmin to a given server use:

docker run --name myadmin -d -e PMA_HOST=dbhost -p 8080:80 phpmyadmin/phpmyadmin

To connect phpMyAdmin to more servers use:

docker run --name myadmin -d -e PMA_HOSTS=dbhost1,dbhost2,dbhost3 -p 8080:80 phpmyadmin/phpmyadmin

To use arbitrary server option:

docker run --name myadmin -d --link mysql_db_server:db -p 8080:80 -e PMA_ARBITRARY=1 phpmyadmin/phpmyadmin

You can also link the database container using Docker:

docker run --name phpmyadmin -d --link mysql_db_server:db -p 8080:80 phpmyadmin/phpmyadmin

Käivitatud täiendava konfiguratsiooniga:

docker run --name phpmyadmin -d --link mysql_db_server:db -p 8080:80 -v /some/local/directory/config.user.inc.php:/etc/phpmyadmin/config.user.inc.php phpmyadmin/phpmyadmin

Käivitatud täiendavate teemadega:

docker run --name phpmyadmin -d --link mysql_db_server:db -p 8080:80 -v /custom/phpmyadmin/theme/:/www/themes/theme/ phpmyadmin/phpmyadmin

Using docker-compose

Alternatively, you can also use docker-compose with the docker-compose.yml from <https://github.com/phpmyadmin/docker>. This will run phpMyAdmin with an arbitrary server - allowing you to specify MySQL/MariaDB server on the login page.

docker-compose up -d

Konfiguratsioonifaili kohandamine docker-compose’iga

You can use an external file to customize phpMyAdmin configuration and pass it using the volumes directive:

phpmyadmin:
    image: phpmyadmin/phpmyadmin
    container_name: phpmyadmin
    environment:
     - PMA_ARBITRARY=1
    restart: always
    ports:
     - 8080:80
    volumes:
     - /sessions
     - ~/docker/phpmyadmin/config.user.inc.php:/etc/phpmyadmin/config.user.inc.php
     - /custom/phpmyadmin/theme/:/www/themes/theme/

Running behind haproxy in a subdirectory

When you want to expose phpMyAdmin running in a Docker container in a subdirectory, you need to rewrite the request path in the server proxying the requests.

For example, using haproxy it can be done as:

frontend http
    bind *:80
    option forwardfor
    option http-server-close

    ### NETWORK restriction
    acl LOCALNET  src 10.0.0.0/8 192.168.0.0/16 172.16.0.0/12

    # /phpmyadmin
    acl phpmyadmin  path_dir /phpmyadmin
    use_backend phpmyadmin if phpmyadmin LOCALNET

backend phpmyadmin
    mode http

    reqirep  ^(GET|POST|HEAD)\ /phpmyadmin/(.*)     \1\ /\2

    # phpMyAdmin container IP
    server localhost     172.30.21.21:80

When using traefik, something like following should work:

defaultEntryPoints = ["http"]
[entryPoints]
  [entryPoints.http]
  address = ":80"
    [entryPoints.http.redirect]
      regex = "(http:\\/\\/[^\\/]+\\/([^\\?\\.]+)[^\\/])$"
      replacement = "$1/"

[backends]
  [backends.myadmin]
    [backends.myadmin.servers.myadmin]
    url="http://internal.address.to.pma"

[frontends]
   [frontends.myadmin]
   backend = "myadmin"
   passHostHeader = true
     [frontends.myadmin.routes.default]
     rule="PathPrefixStrip:/phpmyadmin/;AddPrefix:/"

You then should specify PMA_ABSOLUTE_URI in the docker-compose configuration:

version: '2'

services:
  phpmyadmin:
    restart: always
    image: phpmyadmin/phpmyadmin
    container_name: phpmyadmin
    hostname: phpmyadmin
    domainname: example.com
    ports:
      - 8000:80
    environment:
      - PMA_HOSTS=172.26.36.7,172.26.36.8,172.26.36.9,172.26.36.10
      - PMA_VERBOSES=production-db1,production-db2,dev-db1,dev-db2
      - PMA_USER=root
      - PMA_PASSWORD=
      - PMA_ABSOLUTE_URI=http://example.com/phpmyadmin/

IBM Cloud

One of our users has created a helpful guide for installing phpMyAdmin on the IBM Cloud platform.

Kiirpaigaldus

  1. Vali sobiv levituskomplekt phpmyadmin.net allalaadimiste leheküljelt. Mõned komplektid sisaldavad ainult inglise keelsed teateid, teised sisaldavad kõiki keeli. Me eeldame, et sa valid komplekti, mille nimi on kujul phpMyAdmin-x.x.x-all-languages.tar.gz.
  2. Kontrolli, et oled alla laadinud ehtsa arhiivi. Täpsemalt vaata Kontrollitakse phpMyAdmini väljalaskeid.
  3. Paki komplekt lahti (kindlasti paki lahti alamkataloogid): käivita tar -xzvf phpMyAdmin_x.x.x-all-languages.tar.gz oma veebiserveri dokumentide juurkataloogis. Kui sul puudub otsene ligipääs oma dokumentide juurkataloogile, siis pane failid kohaliku masina kataloogi ja pärast neljandat sammu teisalda kataloogi omage veebiserverisse kasutades näiteks FTP’d.
  4. Kindlusta, et kõikidel skriptidel oleks õige omanik (kui PHP töötab turvalises režiimis, siis erinevus mõne skripti omanikus põhjustab probleeme). Vaata soovitusi 4.2 What’s the preferred way of making phpMyAdmin secure against evil access? ja 1.26 I just installed phpMyAdmin in my document root of IIS but I get the error „No input file specified“ when trying to run phpMyAdmin..
  5. Nüüd pead sa seadistama oma paigalduse. Selleks on kaks meetodit. Traditsiooniliselt pidid kasutajad muutma käsitsi config.inc.php, kuid nüüd on võimalik graafilise paigalduse eelistajatel kasutaja visardi stiilis seadistamise skripti.

Faili loomine käsitsi

To manually create the file, simply use your text editor to create the file config.inc.php (you can copy config.sample.inc.php to get a minimal configuration file) in the main (top-level) phpMyAdmin directory (the one that contains index.php). phpMyAdmin first loads the default configuration values and then overrides those values with anything found in config.inc.php. If the default value is okay for a particular setting, there is no need to include it in config.inc.php. You’ll probably need only a few directives to get going; a simple configuration may look like this:

<?php
// use here a value of your choice at least 32 chars long
$cfg['blowfish_secret'] = '1{dd0`<Q),5XP_:R9UK%%8\"EEcyH#{o';

$i=0;
$i++;
$cfg['Servers'][$i]['auth_type']     = 'cookie';
// if you insist on "root" having no password:
// $cfg['Servers'][$i]['AllowNoPassword'] = true;

Või, kui sa soovid, et igal sisselogimisel parooli ei küsitaks:

<?php

$i=0;
$i++;
$cfg['Servers'][$i]['user']          = 'root';
$cfg['Servers'][$i]['password']      = 'changeme'; // use here your password
$cfg['Servers'][$i]['auth_type']     = 'config';

Hoiatus

Storing passwords in the configuration is insecure as anybody can then manipulate your database.

Kõigi sätete võimalike väärtuste seletused leiad seadistuste dokumendist Seadistamine.

Häälestusskripti kasutamine

Faili config.inc.php käsitsi muutmise asemel võid kasutada phpMyAdmin’i automaathäälestamist. Selle faili saab luua häälestusprogrammiga ja sa saata alla laadida, et hiljem veebiserverisse üles laadida.

Next, open your browser and visit the location where you installed phpMyAdmin, with the /setup suffix. The changes are not saved to the server, you need to use the Download button to save them to your computer and then upload to the server.

Fail on nüüd kasutamiseks valmis. Sa võid teda vaadata või muuta lemmiktoimetis, kui sa soovid määrata mõne vähemkasutatud sätte, mida häälestusskript ei toeta, väärtust.

  1. Kui sa kasutad auth_type „config“, siis on soovitatav, et sa kaitseksid phpMyAdmin paigalduskataloogi, sest seadistuste kasutamine ei nõua kasutajalt salasõna sisestamist enne phpMyAdmin’i kasutamist. Alternatiivsete autentimismeetodite kasutamine on tungivalt soovitatav. Näiteks lülita sisse HTTP-AUTH failiga .htaccess või muuda auth_type väärtuseks kas „cookie“ või „http“. Lisainformatsiooni leiad ISPs, multi-user installations ja ennekõige 4.4 phpMyAdmin always gives „Access denied“ when using HTTP authentication..
  2. Ava phpMyAdmin peakataloog oma veebilehitsejas. phpMyAdmin peaks nüüd näitama tervituskuva ja sinu andmebaase, või logimis dialoogi, kui valitud on kas HTTP või küpsistel põhinev autentimisrežiim.

Setup script on Debian, Ubuntu and derivatives

Debian and Ubuntu have changed the way in which the setup script is enabled and disabled, in a way that single command has to be executed for either of these.

Häälestuse muutmise lubamiseks käivita:

/usr/sbin/pma-configure

Häälestuse muutmise keelamiseks käivita:

/usr/sbin/pma-secure

openSUSE paigalduse skript

Some openSUSE releases do not include setup script in the package. In case you want to generate configuration on these you can either download original package from <https://www.phpmyadmin.net/> or use setup script on our demo server: <https://demo.phpmyadmin.net/master/setup/>.

Kontrollitakse phpMyAdmini väljalaskeid

Alates 2015 aasta juulist on kõik phpMyAdmini väljalasked krüptograafiliselt allkirjastatud reliisi väljaandja, kes jaanuaris 2016 oli Marc Delisle, allkirjaga. Tema võtme ID on 0xFEFC65D181AF644A ja ta PGP sõrmejälg on:

436F F188 4B1A 0C3F DCBF 0D79 FEFC 65D1 81AF 644A

and you can get more identification information from <https://keybase.io/lem9>.

Beginning in January 2016, the release manager is Isaac Bennetch. His key id is 0xCE752F178259BD92, and his PGP fingerprint is:

3D06 A59E CE73 0EB7 1B51 1C17 CE75 2F17 8259 BD92

and you can get more identification information from <https://keybase.io/ibennetch>.

Some additional downloads (for example themes) might be signed by Michal Čihař. His key id is 0x9C27B31342B7511D, and his PGP fingerprint is:

63CB 1DF1 EF12 CF2A C0EE 5A32 9C27 B313 42B7 511D

and you can get more identification information from <https://keybase.io/nijel>.

Sa peaksid kontrollima, et arhiivi signatuur vastab alla laetud arhiivile. Sedasi saad olla kindel, et sa kasutad sama koodi, mis on välja antud. Samuti peaksid kontrollima ja allkirja kuupäeva, et olla kindel uusima versiooni alla laadimises.

Iga arhiiviga on kaasas ka .asc fail, milles on arhiivi PGP signatuur. Kui mõlemad failid on ükskord samas kataloogis, siis saad sa signatuuri kontrollida järgmiselt:

$ gpg --verify phpMyAdmin-4.5.4.1-all-languages.zip.asc
gpg: Signature made Fri 29 Jan 2016 08:59:37 AM EST using RSA key ID 8259BD92
gpg: Can't check signature: public key not found

Nagu näha on kurdab PGP, et ta ei tea avalikku võtit. Siinkohal peaksid tegema ühe järgnevatest sammudest:

$ gpg --import phpmyadmin.keyring
  • Laadi alla ja impordi võti ühest võtmete serverist:
$ gpg --keyserver hkp://pgp.mit.edu --recv-keys 3D06A59ECE730EB71B511C17CE752F178259BD92
gpg: requesting key 8259BD92 from hkp server pgp.mit.edu
gpg: key 8259BD92: public key "Isaac Bennetch <bennetch@gmail.com>" imported
gpg: no ultimately trusted keys found
gpg: Total number processed: 1
gpg:               imported: 1  (RSA: 1)

See parandab olukorda mõnevõrra - siinkohal peaksid kontrollima, et antud võtme signatuur on õige, kuid sa ei saa veel usaldada nime, mida võti kasutab:

$ gpg --verify phpMyAdmin-4.5.4.1-all-languages.zip.asc
gpg: Signature made Fri 29 Jan 2016 08:59:37 AM EST using RSA key ID 8259BD92
gpg: Good signature from "Isaac Bennetch <bennetch@gmail.com>"
gpg:                 aka "Isaac Bennetch <isaac@bennetch.org>"
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: 3D06 A59E CE73 0EB7 1B51  1C17 CE75 2F17 8259 BD92

Probleem on selles, et antud nimega saab võtme väljastada igaüks. Sa pead olema kindel, et antud võtme omanik on tõesti selle väljastaja. „GNU Privaatsuse Käsiraamatus“ käsitletakse seda teemat peatükis Teise võtmete valideerimine sinu avalikus võtmerõngas. Kõige kindlam meetod selleks on kohtuda arendajaga isiklikult ja vahetada oma võtmete sõrmejäljed; samas võid loota ka usalduse võrgule. Sellisel juhul saad sa kontrollida võtit transitiivselt nende arendajate võtmete allkirjade kaudu, kellega oled isiklikult kohtunud.

Hoiatus ei ilmu siis, kui võtit usaldatakse:

$ gpg --verify phpMyAdmin-4.5.4.1-all-languages.zip.asc
gpg: Signature made Fri 29 Jan 2016 08:59:37 AM EST using RSA key ID 8259BD92
gpg: Good signature from "Isaac Bennetch <bennetch@gmail.com>" [full]

Juhul kui signatuur on vale (arhiivi on muudetud), saad sa selge veateate sõltumata sellest, kas võti on usaldusväärne või mitte:

$ gpg --verify phpMyAdmin-4.5.4.1-all-languages.zip.asc
gpg: Signature made Fri 29 Jan 2016 08:59:37 AM EST using RSA key ID 8259BD92
gpg: BAD signature from "Isaac Bennetch <bennetch@gmail.com>" [unknown]

phpMyAdmin’i seadistuse salvestuskoht

Muudetud versioonis 3.4.0: Prior to phpMyAdmin 3.4.0 this was called Linked Tables Infrastructure, but the name was changed due to the extended scope of the storage.

Mitmete lisavõimaluste (Järjehoidjad, kommentaarid, SQL-ajalugu, jälgimismehhanism, PDF failide loomine, Transformations, Seosed, jne.) kasutamiseks pead looma teatavad lisatabelid. Need tabelid võivad asuda nii sinu andmebaasis kui ka keskses andmebaasis mitmekasutaja paigalduse korral (selle andmebaasi poole pöördutakse juhtkasutajana ja ülejäänud kasutajatel ei tohiks sellele andmebaasile õiguseid olla).

Täisautomaatne häälestus

Paljudel juhtudel on see andmebaasistruktuur automaatselt loodav ja häälestatav. Seda kutsutake „häälestuse vabaks“ režiimiks ja see on eriti kasulik jagatud hostingus. „Häälestuse vaba“ režiim on vaikimisi aktiveeritud; selle keelamiseks määra $cfg['ZeroConf'] väärtuseks false.

Järgmised kolm kasutusjuhtu on käivad häälestuse vaba režiimi alla:

  • Kui siseneda andmebaasi, millel puuduvad häälestuse salvestamise tabelid. phpMyAdmin võimaldab nende loomise kaardilt „Operatsioonid“ .
  • Sisenedes andmebaasi, milles tabelid on juba olemas, tuvastab tarkvara need automaatselt ja hakkab neid kasutama. See on kõige tavalisem juhtum, kus tabelid loodi alguses automaatselt ja neid kasutatakse pidevalt kasutajat segamata. See on ka kõige kasulikumt jagatud hostingus, kus kasutaja ei saa faili config.inc.php muuta ja tal on üldjuhul ligipääs ainult ühele andmebaasile.
  • Kui kasutajal on ligipääs mitmele andmebaasile ja ta sisestab andmebaasi, milles asuvad häälestuse salvestamise tabelid ja seejärel valib mingi teise andmebaasi, siis phpMyAdmin jätkab tabelite kasutamist esimesest andmebaasist ning kasutaja ei pea uude andmebaasi looma täiendavaid tabeleid.

Käsitsi häälestamine

Palun vaata oma ./sql/ kataloogi, millest sa leiad faili create_tables.sql. (Kui sa kasutad Windowsi serverit, siis pööra erilist tähelepanu 1.23 I’m running MySQL on a Win32 machine. Each time I create a new table the table and column names are changed to lowercase!’le).

Kui sul juba on see taristu ja:

  • oled uuendanud MySQL’i versioonile 4.1.2 või uuem, siis kasuta palun faili sql/upgrade_tables_mysql_4_1_2+.sql.
  • uuendanud phpMyAdmin versioonilt 2.5.0 või uuemalt vähemalt versiooniks 4.3.0, kasuta faili sql/upgrade_column_info_4_3_0+.sql.
  • uuendatud versioonile phpMyAdmin 4.7.0 või uuem versioonist 4.3.0 või uuem, palun kasuta faili sql/upgrade_tables_4_7_0+.sql.

ja seejärel loo uued tabelid importides faili sql/create_tables.sql.

Sa võid kasutada oma phpMyAdmin’i, et need tabelid luua. Palun arvesta aga sellega, et sa või vajada erilisi (administraatori) privileege, et luua andmebaas ja tabelid, ja et see skript võib vajada natuke täiendamist, sõltuvalt andmebaasi nimest.

Kui sa oled importinud faili sql/create_tables.sql, siis pead määrama tabelite nimed oma config.inc.php failis. Selleks vajalikud sätted leiad siit Seadistamine.

Sul on vaja luua ka kontrollkasutaja ($cfg['Servers'][$i]['controluser'] ja $cfg['Servers'][$i]['controlpass'] sätted), kellel on sobivad õigused nendele tabelitele. Näiteks saad ta luua kasutades järgmist lauset:

And for any MariaDB version:

CREATE USER 'pma'@'localhost' IDENTIFIED VIA mysql_native_password USING 'pmapass';
GRANT SELECT, INSERT, UPDATE, DELETE ON `<pma_db>`.* TO 'pma'@'localhost';

Alates MySQL 8.0:

CREATE USER 'pma'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'pmapass';
GRANT SELECT, INSERT, UPDATE, DELETE ON <pma_db>.* TO 'pma'@'localhost';

For MySQL older than 8.0:

CREATE USER 'pma'@'localhost' IDENTIFIED WITH mysql_native_password AS 'pmapass';
GRANT SELECT, INSERT, UPDATE, DELETE ON <pma_db>.* TO 'pma'@'localhost';

Note that MySQL installations with PHP older than 7.4 and MySQL newer than 8.0 may require using the mysql_native_password authentication as a workaround, see 1.45 I get an error message about unknown authentication method caching_sha2_password when trying to log in for details.

Vanema versiooni uuendamine

Hoiatus

Mitte kunagi ei tohi phpMyAdmini uut versiooni lahti pakkida vana paigalduse kohale. Kustuta alati vanad failid eest ära ja hoia alles ainult häälestus.

This way, you will not leave any old or outdated files in the directory, which can have severe security implications or can cause various breakages.

Lihtsalt kopeeri eelmise versiooni kataloogist fail config.inc.php uue versiooni kataloogi. Vanemate versioonide häälestuse failid võivad vajada vähest uuendamist, sest mõned sätted võivad olla muutunud või eemaldatud. Selleks, et säiitada ühilduvus PHP versiooniga 5.3 ja uuematega, kustuta failist lause set_magic_quotes_runtime(0);; see võib asuda häälestuse faili lõpu lähedal.

The complete upgrade can be performed in a few simple steps:

  1. Download the latest phpMyAdmin version from <https://www.phpmyadmin.net/downloads/>.
  2. Rename existing phpMyAdmin folder (for example to phpmyadmin-old).
  3. Unpack freshly downloaded phpMyAdmin to the desired location (for example phpmyadmin).
  4. Copy config.inc.php` from old location (phpmyadmin-old) to the new one (phpmyadmin).
  5. Test that everything works properly.
  6. Remove backup of a previous version (phpmyadmin-old).

Kui sa oled uuendanud om MySQL serveri versiooni 4.1.2 versioonile 5.x ja kui sa kasutad phpMyAdmin seadistuste salvestuskohta, siis peaksid käivitama SQL skripti sql/upgrade_tables_mysql_4_1_2+.sql.

Kui sa oled uuendanud oma phpMyAdmini versioonist 2.5.0 (või uuem) versioonile vähemalt 4.3.0 ja sa kasutad phpMyAdmin seadistuste salvestuskohta, siis peaksid käivitama SQL skripti sql/upgrade_column_info_4_3_0+.sql.

Ära unusta tühjendamast brauseri vahemälu ja lõpetamast vana sessiooni logides välja ja uuesti sisse.

Autentimisrežiimide kasutamine

HTTP ja küpsiste põhised autentimisrežiimid on soovitatavad mitme kasutaja keskkondades, kus sa soovid anda kasutajatele ligipääsu nende endi andmebaasidele ja ei soovi, et nad mängiksid teiste andmebaasidega. Sõltumata sellest arvesta aga sellega, et MS Internet Explorer tundub olevat küpsiste kasutamisel tõeliselt vigane, vähemalt versioonini 6. Isegi ühe kasutaja keskkonnas võid sa eelistada HTTP või küpsiste režiimi kasutamist, sest siis ei ole su kasutaja ja parooli paar avalikult seadistuste failis.

HTTP ja küpsistega autentimisrežiimid on rohkem turvalisemad: MySQL sisse logimise informatsiooni ei pea määrama phpMyAdmin seadistuste failis (välja arvatud ainult $cfg['Servers'][$i]['controluser']). Siiski, arvesta sellega, et parool rändab veebilehitsejast serverini avatekstina, kui sa juhuslikult ei kasuta HTTPS protokolli. Küpsiste režiimis salvestatakse AES algoritmiga krüpteeritud parool ajutises küpsises.

Sellisel juhul tuleks igale tõelisele kasutajale anda õigused kindlatele andmebaasidele. Harilikult ei tohiks anda globaalseid õigused tavakasutajatele, kui sa ei tea, mida need õigused lubavad (näiteks: sa loomas superkasutajat). Näide: kõigi õiguste andmine kasutajale real_user andmebaasis user_base:

GRANT ALL PRIVILEGES ON user_base.* TO 'real_user'@localhost IDENTIFIED BY 'real_password';

Mida kasutaja saab nüüd teha sõltub täielikult MySQL kasutajate haldamise süsteemist. HTTP või küpsistega autentimis režiimis ei pea sa täitma kasutaja ja salasõna sätteid $cfg['Servers'] all.

HTTP autentimisrežiim

Märkus

There is no way to do proper logout in HTTP authentication, most browsers will remember credentials until there is no different successful authentication. Because of this, this method has a limitation that you can not login with the same user after logout.

Sisselogimise autentimisrežiim

Väga lihtne näide sellest, kuidas salvestada mandaat sessioonis, asub failis examples/signon.php:

<?php
/**
 * Single signon for phpMyAdmin
 *
 * This is just example how to use session based single signon with
 * phpMyAdmin, it is not intended to be perfect code and look, only
 * shows how you can integrate this functionality in your application.
 */

declare(strict_types=1);

/* Use cookies for session */
ini_set('session.use_cookies', 'true');
/* Change this to true if using phpMyAdmin over https */
$secure_cookie = false;
/* Need to have cookie visible from parent directory */
session_set_cookie_params(0, '/', '', $secure_cookie, true);
/* Create signon session */
$session_name = 'SignonSession';
session_name($session_name);
// Uncomment and change the following line to match your $cfg['SessionSavePath']
//session_save_path('/foobar');
@session_start();

/* Was data posted? */
if (isset($_POST['user'])) {
    /* Store there credentials */
    $_SESSION['PMA_single_signon_user'] = $_POST['user'];
    $_SESSION['PMA_single_signon_password'] = $_POST['password'];
    $_SESSION['PMA_single_signon_host'] = $_POST['host'];
    $_SESSION['PMA_single_signon_port'] = $_POST['port'];
    /* Update another field of server configuration */
    $_SESSION['PMA_single_signon_cfgupdate'] = ['verbose' => 'Signon test'];
    $_SESSION['PMA_single_signon_HMAC_secret'] = hash('sha1', uniqid(strval(random_int(0, mt_getrandmax())), true));
    $id = session_id();
    /* Close that session */
    @session_write_close();
    /* Redirect to phpMyAdmin (should use absolute URL here!) */
    header('Location: ../index.php');
} else {
    /* Show simple form */
    header('Content-Type: text/html; charset=utf-8');

    echo '<?xml version="1.0" encoding="utf-8"?>' . "\n";
    echo '<!DOCTYPE HTML>
<html lang="en" dir="ltr">
<head>
<link rel="icon" href="../favicon.ico" type="image/x-icon">
<link rel="shortcut icon" href="../favicon.ico" type="image/x-icon">
<meta charset="utf-8">
<title>phpMyAdmin single signon example</title>
</head>
<body>';

    if (isset($_SESSION['PMA_single_signon_error_message'])) {
        echo '<p class="error">';
        echo $_SESSION['PMA_single_signon_error_message'];
        echo '</p>';
    }

    echo '<form action="signon.php" method="post">
Username: <input type="text" name="user" autocomplete="username"><br>
Password: <input type="password" name="password" autocomplete="current-password"><br>
Host: (will use the one from config.inc.php by default)
<input type="text" name="host"><br>
Port: (will use the one from config.inc.php by default)
<input type="text" name="port"><br>
<input type="submit">
</form>
</body>
</html>';
}

Alternatiivselt võid kasutada seda meetodit, et liidestada OpenID, nagu on näidatud failis examples/openid.php:

<?php
/**
 * Single signon for phpMyAdmin using OpenID
 *
 * This is just example how to use single signon with phpMyAdmin, it is
 * not intended to be perfect code and look, only shows how you can
 * integrate this functionality in your application.
 *
 * It uses OpenID pear package, see https://pear.php.net/package/OpenID
 *
 * User first authenticates using OpenID and based on content of $AUTH_MAP
 * the login information is passed to phpMyAdmin in session data.
 */

declare(strict_types=1);

if (false === @include_once 'OpenID/RelyingParty.php') {
    exit;
}

/* Change this to true if using phpMyAdmin over https */
$secure_cookie = false;

/**
 * Map of authenticated users to MySQL user/password pairs.
 */
$AUTH_MAP = [
    'https://launchpad.net/~username' => [
        'user' => 'root',
        'password' => '',
    ],
];

// phpcs:disable PSR1.Files.SideEffects,Squiz.Functions.GlobalFunction

/**
 * Simple function to show HTML page with given content.
 *
 * @param string $contents Content to include in page
 */
function Show_page($contents): void
{
    header('Content-Type: text/html; charset=utf-8');

    echo '<?xml version="1.0" encoding="utf-8"?>' . "\n";
    echo '<!DOCTYPE HTML>
<html lang="en" dir="ltr">
<head>
<link rel="icon" href="../favicon.ico" type="image/x-icon">
<link rel="shortcut icon" href="../favicon.ico" type="image/x-icon">
<meta charset="utf-8">
<title>phpMyAdmin OpenID signon example</title>
</head>
<body>';

    if (isset($_SESSION['PMA_single_signon_error_message'])) {
        echo '<p class="error">' . $_SESSION['PMA_single_signon_message'] . '</p>';
        unset($_SESSION['PMA_single_signon_message']);
    }

    echo $contents;
    echo '</body></html>';
}

/**
 * Display error and exit
 *
 * @param Exception $e Exception object
 */
function Die_error($e): void
{
    $contents = "<div class='relyingparty_results'>\n";
    $contents .= '<pre>' . htmlspecialchars($e->getMessage()) . "</pre>\n";
    $contents .= "</div class='relyingparty_results'>";
    Show_page($contents);
    exit;
}

// phpcs:enable

/* Need to have cookie visible from parent directory */
session_set_cookie_params(0, '/', '', $secure_cookie, true);
/* Create signon session */
$session_name = 'SignonSession';
session_name($session_name);
@session_start();

// Determine realm and return_to
$base = 'http';
if (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on') {
    $base .= 's';
}

$base .= '://' . $_SERVER['SERVER_NAME'] . ':' . $_SERVER['SERVER_PORT'];

$realm = $base . '/';
$returnTo = $base . dirname($_SERVER['PHP_SELF']);
if ($returnTo[strlen($returnTo) - 1] !== '/') {
    $returnTo .= '/';
}

$returnTo .= 'openid.php';

/* Display form */
if ((! count($_GET) && ! count($_POST)) || isset($_GET['phpMyAdmin'])) {
    /* Show simple form */
    $content = '<form action="openid.php" method="post">
OpenID: <input type="text" name="identifier"><br>
<input type="submit" name="start">
</form>';
    Show_page($content);
    exit;
}

/* Grab identifier */
$identifier = null;
if (isset($_POST['identifier']) && is_string($_POST['identifier'])) {
    $identifier = $_POST['identifier'];
} elseif (isset($_SESSION['identifier']) && is_string($_SESSION['identifier'])) {
    $identifier = $_SESSION['identifier'];
}

/* Create OpenID object */
try {
    $o = new OpenID_RelyingParty($returnTo, $realm, $identifier);
} catch (Throwable $e) {
    Die_error($e);
}

/* Redirect to OpenID provider */
if (isset($_POST['start'])) {
    try {
        $authRequest = $o->prepare();
    } catch (Throwable $e) {
        Die_error($e);
    }

    $url = $authRequest->getAuthorizeURL();

    header('Location: ' . $url);
    exit;
}

/* Grab query string */
if (! count($_POST)) {
    [, $queryString] = explode('?', $_SERVER['REQUEST_URI']);
} else {
    // Fetch the raw query body
    $queryString = file_get_contents('php://input');
}

/* Check reply */
try {
    $message = new OpenID_Message($queryString, OpenID_Message::FORMAT_HTTP);
} catch (Throwable $e) {
    Die_error($e);
}

$id = $message->get('openid.claimed_id');

if (empty($id) || ! isset($AUTH_MAP[$id])) {
    Show_page('<p>User not allowed!</p>');
    exit;
}

$_SESSION['PMA_single_signon_user'] = $AUTH_MAP[$id]['user'];
$_SESSION['PMA_single_signon_password'] = $AUTH_MAP[$id]['password'];
$_SESSION['PMA_single_signon_HMAC_secret'] = hash('sha1', uniqid(strval(random_int(0, mt_getrandmax())), true));
session_write_close();
/* Redirect to phpMyAdmin (should use absolute URL here!) */
header('Location: ../index.php');

Kui sa soovid edastada mandaadi kasutades mõnda muud meetodit, siis pead looma PHP’s vastava mähise, et need andmed saada ja pead kirjeldama selle sättes $cfg['Servers'][$i]['SignonScript']. Väga minimaalne näide on failis examples/signon-script.php:

<?php
/**
 * Single signon for phpMyAdmin
 *
 * This is just example how to use script based single signon with
 * phpMyAdmin, it is not intended to be perfect code and look, only
 * shows how you can integrate this functionality in your application.
 */

declare(strict_types=1);

// phpcs:disable Squiz.Functions.GlobalFunction

/**
 * This function returns username and password.
 *
 * It can optionally use configured username as parameter.
 *
 * @param string $user User name
 *
 * @return array
 */
function get_login_credentials($user)
{
    /* Optionally we can use passed username */
    if (! empty($user)) {
        return [
            $user,
            'password',
        ];
    }

    /* Here we would retrieve the credentials */
    return [
        'root',
        '',
    ];
}

Autentimisrežiimi seaded

  • See režiim on mõnikord vähem turvaline, sest sa pead täitma $cfg['Servers'][$i]['user'] ja $cfg['Servers'][$i]['password'] väljad (mille tulemusel saavad kõik, kellel on lubatud lugeda faili config.inc.php võimalus avastada su kasutajanimi ja salasõna).
  • KKK sektsioonis ISPs, multi-user installations on kirjeldatud, kuidas kaitsta seadistuste faili.
  • Turvalisuse tõstmiseks selles režiimis tasub kaaluda hosti põhist autentimist $cfg['Servers'][$i]['AllowDeny']['order'] ja $cfg['Servers'][$i]['AllowDeny']['rules'] sätteid.
  • Erinevalt küpsiste ja HTTP režiimist ei nõua kasutajalt sisse logimist phpMyAdmin saidi esmasel laadimisel. See on nii disainitud, ja võimaldab igal külastajal su paigaldust kasutada. Soovitatav on kasutada mõnda ligipääsu piiramise meetodit, näiteks .htaccess fail, millega lülitatakse sisse HTTP-AUTH, või sisenevate HTTP päringute keelamine marsruuteris või tulemüüris on piisavad (kuid jäävad selle juhendi ulatusest välja, ent on kergelt leitavad nt. Google abil).

PhpMyAdmin’i paigalduse turvamine

phpMyAdmin’i meeskond pingutab kõvasti, et programm oleks turvaline. Sellegi poolest on mitmeid võimalusi, kuidas sinu paigaldust teha veelgi turvalisemaks:

  • Follow our Security announcements and upgrade phpMyAdmin whenever new vulnerability is published.

  • Serve phpMyAdmin on HTTPS only. Preferably, you should use HSTS as well, so that you’re protected from protocol downgrade attacks.

  • Ensure your PHP setup follows recommendations for production sites, for example display_errors should be disabled.

  • Kui sa ei tegele just arendamisega ja vajad teste, siis kustuta phpMyAdmini kataloog test.

  • Kustuta phpMyAdmin’i kataloog setup; ilmselt ei ole sul seda vaja pärast esmast seadistust.

  • Vali korrektne autentimise meetod - Küpsistega autentimisrežiim on ilmselt parim variant mitme kasutaja korral.

  • Keela veebiserveri seadistuses juurdepääs failidele alamkataloogides ./libraries/ ja ./templates/. Selline seadistus takistab võimalikke otsinguradade paljastamist ja ristskriptimise vigu, mis võivad koodis esineda. Apache veebiserveriga on see tavaliselt saavutatav faili .htaccess lisamisega nendesse kataloogidesse.

  • Deny access to temporary files, see $cfg['TempDir'] (if that is placed inside your web root, see also Web server upload/save/import directories.

  • Üldiselt on hea mõte kaitsta avalikke phpMyAdmin’i paigaldusi robotite eest, sest tavaliselt ei tee nad mitte midagi head. Sa saad seda teha lisades faili robots.txt oma veebiserveri juurkataloogi või piirates ligipääsu veebiserveri seadistuses. Lähemalt vaata 1.42 How can I prevent robots from accessing phpMyAdmin?.

  • Kui sa ei soovi, et kõik MySQLi kasutajad saaksid kasutada phpMyAdmini, siis kasuta piirangute seadmiseks $cfg['Servers'][$i]['AllowDeny']['rules'] või $cfg['Servers'][$i]['AllowRoot'] juurkasutajana kasutamise keelamiseks.

  • Luba Kaheastmeline autentimine oma kontole.

  • Kaalu phpMyAdmin’i peitmist autentimisproksi taha nii, et kasutajad peavad end autentima enne MySQL’i konto ja salasõna edastamist phpMyAdminile. Selleks pead oma veebiserveris lülitama sisse HTTP autentimise. Näiteks Apache serveris käib see nii:

    AuthType Basic
    AuthName "Restricted Access"
    AuthUserFile /usr/share/phpmyadmin/passwd
    Require valid-user
    

    Siis kui oled häälestust muutnud, pead looma loendi kasutajatest, kelle autentimine on lubatud. Seda saab teha programmiga htpasswd:

    htpasswd -c /usr/share/phpmyadmin/passwd username
    
  • Kui sa kardad automaatrünnakuid, siis võib aidata Captcha seadistamine sätetega $cfg['CaptchaLoginPublicKey'] ja $cfg['CaptchaLoginPrivateKey'].

  • Failed login attempts are logged to syslog (if available, see $cfg['AuthLog']). This can allow using a tool such as fail2ban to block brute-force attempts. Note that the log file used by syslog is not the same as the Apache error or access log files.

  • In case you’re running phpMyAdmin together with other PHP applications, it is generally advised to use separate session storage for phpMyAdmin to avoid possible session-based attacks against it. You can use $cfg['SessionSavePath'] to achieve this.

Luba SSL ühendus andmebaasiserverisse

It is recommended to use SSL when connecting to remote database server. There are several configuration options involved in the SSL setup:

$cfg['Servers'][$i]['ssl']
Defines whether to use SSL at all. If you enable only this, the connection will be encrypted, but there is not authentication of the connection - you can not verify that you are talking to the right server.
$cfg['Servers'][$i]['ssl_key'] ja $cfg['Servers'][$i]['ssl_cert']
Seda kasutatakse kliendi autentimiseks serveris.
$cfg['Servers'][$i]['ssl_ca'] ja $cfg['Servers'][$i]['ssl_ca_path']
The certificate authorities you trust for server certificates. This is used to ensure that you are talking to a trusted server.
$cfg['Servers'][$i]['ssl_verify']
This configuration disables server certificate verification. Use with caution.

When the database server is using a local connection or private network and SSL can not be configured you can use $cfg['MysqlSslWarningSafeHosts'] to explicitly list the hostnames that are considered secure.

Known issues

Users with column-specific privileges are unable to „Browse“

If a user has only column-specific privileges on some (but not all) columns in a table, „Browse“ will fail with an error message.

As a workaround, a bookmarked query with the same name as the table can be created, this will run when using the „Browse“ link instead. Issue 11922.

Trouble logging back in after logging out using ‚http‘ authentication

When using the ‚http‘ auth_type, it can be impossible to log back in (when the logout comes manually or after a period of inactivity). Issue 11898.