Criando um ambiente de desenvolvimento LAMP

LAMP é um acrônimo representando Linux, Apache, MySQL e PHP

Um ambiente LAMP nos dá os elementos básicos para poder programar.

Como o alvo é programar sobre um servidor e não sobre ambiente Desktop, a instalação será sem GUI mas fique livre para faze-lo. Eu mesmo não tenho recursos tão abundantes assim para pôr interface gráfica em um servidor que vou controlar via ssh.

Escolhemos Ubuntu por ser o Linux mais simples de instalar e usar no dia a dia do desenvolvedor. Para produção costumamos colocar CentOS que é mais leve porém às vezes mais nojentinho de configurar.

Se você já tem uma VM com Ubuntu, pode pular para “Instalando LAMP” lá no final

Baixe a última versão estável do Ubuntu

No momento de escrever este artigo, estava na 18.04.4 LTS (Sempre escolha as versões 04 que tem maior durabilidade garantida pela Cannonical)

https://ubuntu.com/download/server
Crie uma máquina virtual

a. Verifique se o local de armazenamento existe

No meu caso, eu deixo todas as máquinas virtuais em uma pasta chamada ‘VirtualBoxes’ alocada na raiz do usuário; isto é: /home/esteban/VirtualBoxes. Então, e não tem uma pasta assim e quer cria-la faça como segue:
```
$ mkdir ~/VirtualBoxes
```
b. Crie sua máquina virtual usando o seguinte comando:
```
$ VBoxManage createvm --name MeuLAMP --ostype Debian_64 --register --basefolder ~/VirtualBoxes/ 
```
O VBoxManage vai responder alguma coisa assim:
```
Virtual machine 'MeuLAMP' is created and registered.
UUID: 3156aee4-8a2e-46dd-ae69-54533c78ff5f
Settings file: '/Users/estebandortta/VirtualBoxes/MeuLAMP/MeuLAMP.vbox'
```
c. Modifique ela para seus parâmetros mínimos.

No caso 512MB de RAM, IOAPIC ligado e uma interface de rede em modo bridge (ponte). Repare que no meu caso, a placa de rede que vai ser usada como ponte é a chamada en1. Por isso que usei ela. No seu caso isso é diferente.

Para obter uma lista das placas conectadas na sua máquina, pode usar o seguinte comando:
```
$ ifconfig | grep "^[a-z0-9]*\:" | awk '{ print $1 }'
```
Uma vez determinado o nome, pode proceder como segue:
```
$ VBoxManage modifyvm MeuLAMP --ioapic on
$ VBoxManage modifyvm MeuLAMP --memory 512 --vram 128
$ VBoxManage modifyvm MeuLAMP --nic1 Bridged  --bridgeadapter1 en1
```
Estes comandos, se bem executados, não devolvem coisa alguma na tela.

d. Agora vamos adicionar um disco

Ele será de tamanho típico (70GB) para este tipo de serviço mas pode ser menor ou maior. Depende de sua capacidade. Não recomendo abaixo de 40GB. Repare que meu download ficou em ~/Downloads/OS/Linux/ubuntu-18.04.3-live-server-amd64.iso então modifique conforme necessário.
```
$ VBoxManage createhd --filename ~/VirtualBoxes/MeuLAMP/MeuLAMP_DISK.vdi --size 70000 --format VDI
$ VBoxManage storagectl MeuLAMP --name "SATA Controller" --add sata --controller IntelAhci
$ VBoxManage internalcommands sethduuid ~/VirtualBoxes/MeuLAMP/MeuLAMP_DISK.vdi
$ VBoxManage storageattach MeuLAMP --storagectl "SATA Controller" --port 0 --device 0 --type hdd --medium  ~/VirtualBoxes/MeuLAMP/MeuLAMP_DISK.vdi
$ VBoxManage storagectl MeuLAMP --name "IDE Controller" --add ide --controller PIIX4
$ VBoxManage storageattach MeuLAMP --storagectl "IDE Controller" --port 1 --device 0 --type dvddrive --medium ~/Downloads/OS/Linux/ubuntu-18.04.3-live-server-amd64.iso
$ VBoxManage modifyvm MeuLAMP --boot1 dvd --boot2 disk --boot3 none --boot4 none
```
e. Configuramos acesso remoto

O configuramos via vrde para podermos lidar com a tela dela no inicio e se alguma coisa acontece com ela durante o uso posterior. O porto (no caso 10004) é da sua escolha apenas use um que não exista.
```
$ VBoxManage modifyvm MeuLAMP --vrde on
$ VBoxManage modifyvm MeuLAMP --vrdemulticon on --vrdeport 10004
```
f. Finalmente, inicie sua máquina para poder configura-la
```
$ VBoxManage startvm MeuLAMP
```
Lembre que posteriormente, podemos usar este comando para iniciar ela “sem-cabeça”. Ou seja, sem interface. Com isso vc poupará alguns recursos de CPU, GPU, RAM, etc. Usamos isso em produção.
```
$ VBoxHeadless --startvm MeuLAMP
```
Coisas a serem feitas durante a instalação

a. Escolha a partição que ocupa o disco inteiro e sem LVM.

Em produção é o contrário. Ou seja, particionamos o disco diferente e usamos LVM que nos permite adicionar mais discos e não apenas mudar o tamanho.

b. Configure seu usuário.

Este é um usuário comum mas com direitos administrativos. Não esqueça a senha mas também não a anote no post-it. Chegado o caso anote ela na manga da camisa. A mulher vai se encarregar de fixar ela na sua memória.

b. Não esqueça de instalar o SSH (Ele vai oferecer OpenSSH logo após particionar o disco)

É importante ter seu SSH instalado pois é por meio dele que você vai acessar sua máquina. Sim, você não está sendo treinado para ser um gnutellinha da vida. Um acesso SSH te libera da exigência brutal de ter uma banda muito larga já que os comandos e seus retornos são textuais.

c. Deixe o restante como está.

Se precisar de proxy, indique no momento adequado.

d. Aguarde até o fim.

Ele vai demorar baixando as atualizações de segurança. Deixe rolar. Melhor agora do que depois.

c. Caso a atualização der problemas escolha “Cancel Update and Reboot”
Coisas a serem feitas após a instalação

Quando chegue ao final da instalação, o sistema instalado vai reiniciar. Observe que ele solicita para remover o disco de instalação. Como colocamos o disco de instalação como “CD-ROM”, o instalador já se encarregou de “ejetar” o mesmo. É só reiniciar (dando ENTER na VM) e boa.

Assim que a máquina reinicie, ingresse nela usando seu usuário e senha cadastrado no primeiro passo.

Na primeira vez, ele vai estar ainda configurando algumas coisas, então tenha paciência.

A única coisa que interessa dessa entrada, é pegar o IP dela para poder acessa-la via SSH.

Obtemos esse IP usando o comando ifconfig da seguinte maneira:
```
esteban@meulamp:~$ ifconfig
```
Ele nos devolverá alguma coisa assim:
```
enp0s3: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
       inet 192.168.0.152  netmask 255.255.255.0  broadcast 192.168.0.255
       inet6 fe80::a00:27ff:fe07:8f8b  prefixlen 64  scopeid 0x20<link>
       ether 08:00:27:07:8f:8b  txqueuelen 1000  (Ethernet)
       RX packets 855  bytes 642531 (642.5 KB)
       RX errors 0  dropped 2  overruns 0  frame 0
       TX packets 243  bytes 30082 (30.0 KB)
       TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
       inet 127.0.0.1  netmask 255.0.0.0
       inet6 ::1  prefixlen 128  scopeid 0x10<host>
       loop  txqueuelen 1000  (Local Loopback)
       RX packets 104  bytes 8136 (8.1 KB)
       RX errors 0  dropped 0  overruns 0  frame 0
       TX packets 104  bytes 8136 (8.1 KB)
       TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
```
Mas desse trambolho todo só nos interessa o IP da primeira placa. A ‘lo’ é uma placa virtual que existe em todo linux para que a pilha TCP/IP funcione. (Lembre que X11 é um servidor que roda no seu próprio micro e sobre TCP/IP. Assim como ele há um monte de programas que esperam que vc tenha uma pilha TCP/IP ativa. Por isso ela está embutida).

Então, simplificamos para o seguinte comando para obtermos o IP da máquina:
```
esteban@meulamp:~$ ifconfig | grep -w inet | grep -vw 127 | awk '{ print $2 }'
```
Com este comando mais simples, direto, eficiente, bonito, fácil de lembrar, obtemos apenas o IP da máquina. No meu caso a saída se resume a isto aqui:
```
192.168.0.152
```
Agora, devemos reconhecer que é um saco ter que abrir a máquina virtual para saber qual IP que ele pegou. Por outro lado, precisamos de essa informação para trabalhar. Comigo acontece de que geralmente não posso deixar ela com IP fixo já que uso ela em diferentes redes.

Uma forma de solucionar isso, é que a própria máquina mostre o IP que pegou na tela antes do login. Desta forma, apenas abrir a tela da VM (Lebre que vamos usar sem tela) já nos mostra esse IP. (Eu não sei vocês, mas eu esqueço dos IPs fixos tb, então eu coloco em tudo quanto é máquina)

Para conseguir isso, vamos modificar o arquivo /etc/issue que é o arquivo que é mostrado no fim do processo de inicialização e logo antes do login.

Como minha placa chama-se enp0s3 (Detesto esses nomes novos, gostava de quando eram eth0 por exemplo) o meu arquivo /etc/issue fica assim:
```
Ubuntu 18.04.4 LTS n l
enp0s3: 4{enp0s3}
------------------------------------------
```
Ao reiniciar a máquina virtual, lá estará a informação que preciso para poder trabalhar.
Configurando seu acesso via SSH

Usar uma máquina virtual via tela é pedir para sofrer. Ela é mais lenta, não tem jeito.

Mesmo se instalou a GUI (como é o caso de Windows Desktop por exemplo que não tem como instalar sem interface gráfica) o melhor é o acesso remoto. Claro, há exeções, mas a regra é essa.

Bem, antes de se apaixonar pelo ssh, você tem que ser triducidado por ele.

Se seu ambiente é Windows, um cliente ssh potável é o PuTTY (https://putty.org) mas o que eu mais gosto é Cygwin (https://www.cygwin.com). Agora, com isso de que o Windows10 já vem com bash (e Ubuntu) embarcado, imagino que o melhor seja usar a opção que vem embarcada.

Eu vou supor que está usando Linux, Cygwin ou bash embarcado.

a. Acesse sua máquina virtual desde a linha de comandos da sua máquina. No meu caso fica assim:
```
$ ssh esteban@192.168.0.152
```
Por ser a primeira vez, o meu bash responde assim:
```
The authenticity of host '192.168.0.152 (192.168.0.152)' can't be established.
ECDSA key fingerprint is SHA256:poNetFdUSSEYn8tH2Mu7Vy7NLdq25lFaCJ449rt2bjw.
Are you sure you want to continue connecting (yes/no)?
```
Ao que eu respondo que sim em inglês fluente. Ou seja “yes” e não apenas “y”

Com isso o servidor fica registrado na lista de alvos conhecidos pelo ssh

Logo apósi digito a senha que registrei na hora da instalação e pronto, estou nele.

Mas vamos sair, porque -não sei vocês- mas eu detesto ter que lembrar de senhas e tal.

Para sair, digitamos exit ou usamos ctrl-d que dá na mesma.

SÓ CONTINUE SE VOLTOU NA SUA MÁQUINA MÃE

b. Tem ou não um par de chaves na sua máquina mãe?

Pode acontecer que você não tenha um par de chaves criadas. Para verificar se tem, use o seguinte comando:
```
$ ls ~/.ssh/*
```
Se ele mostra dois arquivos id_rsa e id_rsa.pub, você já tem as chaves criadas e não há de que se preocupar (a não ser, claro que tenha criado as chaves com senha e as tenha esquecido)

Se ele mostrar alguma coisa parecida com a imagem abaixo é porque você não tem o par de chaves:
```
ls: cannot access '/home/esteban/.ssh/': No such file or directory
```
Caso, então, tenha que criar esse par de chaves, o fazemos usando o seguinte comando:
```
$ ssh-keygen
```
Deixe que o demônio do usuário Windows entre em você e dé ENTER até o final. Dessa forma criará um par de chaves que não precisam senha para serem usadas. (Em produção você coloca senha nelas)

A saída fica mais ou menos assim:
```
Generating public/private rsa key pair.
Enter file in which to save the key (/home/esteban/.ssh/id_rsa): 
Created directory '/home/esteban/.ssh'.
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /home/esteban/.ssh/id_rsa.
Your public key has been saved in /home/esteban/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:1h2/DAEBwxLLwiKYFSyY3FSiFtWRAvO1t8snCgGxCAY esteban@meulamp
The key's randomart image is:
+---[RSA 2048]----+
|EOB=o++oo.o.     |
|O+O+o+o... .     |
|=*..+.oo    o    |
|.... .. .. . +   |
|   .   .S . o .  |
|    . ...    o . |
|   .   + .    o  |
|    . . o        |
|     .           |
+----[SHA256]-----+
```
c. Copie sua chave pública para a VM

Para poder facilitar o acesso via SSH, você agora vai copiar sua chave pública para a máquina que criou. No meu caso fica assim:
```
$ ssh-copy-id esteban@192.168.0.152
```
E ele produzirá uma saída semelhante a esta
```
/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/Users/estebandortta/.ssh/id_rsa.pub"
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
esteban@192.168.0.152's password: 

Number of key(s) added:        1

Now try logging into the machine, with:   "ssh 'esteban@192.168.0.152'"
and check to make sure that only the key(s) you wanted were added.
```
Eu digitei a senha da VM quando me pediu. Se você criou seu par de chaves com senha, vai pedir essa senha tb. Ai vc vai lembrar o porque que eu disse para colocar sem senha.

Bem, a partir deste momento entrar na sua máquina virtual via ssh será tão simples como fazer
```
$ ssh esteban@192.168.0.152
```
E ele deve ir sem pedir senha (a não ser que o par de chaves…bla bla bla)
Instalando o LAMP

Entraremos na virtual. Use o comando similar ao seguinte
```
$ ssh esteban@192.168.0.152
```
a. Instale o básico

O que é o básico no LAMP?

Bom, sendo que está no Linux, só falta AMP (Apache, MySQL e PHP)

Existem pacotes prontos que faremos bem em evitar pois buscamos aprender o que é – de fato – importante.

Primeiro atualizaremos a base instalada (isso pode levar um tempinho a primeira vez)
```
esteban@meulamp:~$ sudo apt-get update -y
```
Ele vai pedir a senha de usuário para poder fazer sudo

Em lugar do MySQL vamos instalar o MariaDB. (MariaDB é um fork de MySQL que o criador de MySQL fez quando abandonou a Oracle. O criador do MySQL tinha ido para a Oracle contando com que a Oracle ia manter seus tentáculos longe e manter o MySQL aberto. Como isso não aconteceu, ele foi embora. Perdeu o nome MySQL mas o software é o mesmo… e manteve a dignidade que – nos tempos que correm – digamos que é importante)
```
esteban@meulamp:~$ sudo apt-get install apache2 php mariadb-server mariadb-client php-mysql -y
```
```
Dependendo de sua distribuição, pode ser que o apache não esteja configurado para iniciar junto com o sistema. Habilite o apache e inicie ele com estes dois comandos:

esteban@meulamp:~$ sudo systemctl enable apache2
esteban@meulamp:~$ sudo systemctl start apache2
```
Dessa forma, quando você reiniciar sua máquina, o apache estará funcionando mas para continuar agora, ele também estará funcionando.

b.Configure o acesso ao banco de dados

Uma vez instalado, é bom configurar o banco de dados. Basicamente precisamos que ele seja seguro o suficiente como para trabalhar, mas tb que não encha o saco com muitas exigências.
```
esteban@meulamp:~$ sudo mysql_secure_installation
```
Assim que ele é instalado, o root está sem senha. Então quando perguntado, crie uma senha para root.
- Depois remova os usuários anónimos
- Permita acesso remoto pelo root (em produção é o contrário)
- Remova a base de testes
- Recarregue sua tabela de privilegios
Pronto, seu MariaDB está configurado. Agora reinicie ele:
```
esteban@meulamp:~$ sudo systemctl restart mariadb
```
E teste o seu acesso local:
```
esteban@meulamp:~$ mysql -u root -p
```
Se tudo deu certo, você vai ter uma tela parecida com esta:
```
Welcome to the MariaDB monitor.  Commands end with ; or g.
Your MariaDB connection id is 35
Server version: 10.1.44-MariaDB-0ubuntu0.18.04.1 Ubuntu 18.04

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or 'h' for help. Type 'c' to clear the current input statement.

MariaDB [(none)]> Bye
```
Mas, pode ser que sua combinação de Ubuntu/MariaDB esteja meio louca. Geralmente o problema está com o protocolo de autenticação. Nesse caso ele vai mostrar uma saída como a seguinte:
```
esteban@meulamp:~$ mysql -u root -p
Enter password: 
ERROR 1698 (28000): Access denied for user 'root'@'localhost'
```
Se tiver esse problema você pode proceder da seguinte forma primeiro para confirmar o erro e depois para corregi-lo:
```
esteban@meulamp:~$ sudo mysql
MariaDB [(none)]> use mysql;
MariaDB [mysql]> select user, plugin from user;
```
Ele vai mostrar para você uma saida com esta que serve para identificar se esse é seu problema:
```
+------+-------------+
| user | plugin      |
+------+-------------+
| root | unix_socket |
+------+-------------+
1 row in set (0.00 sec)
```
Corrigimos isso assim:
```
MariaDB [mysql]> update user set plugin='mysql_native_password' where user='root';
MariaDB [mysql]> flush privileges;
MariaDB [mysql]> exit
```
Agora, desde seu usuário comum, você deve ser capaz de entrar no mysql localmente
```
esteban@meulamp:~$ mysql -u root -p
```
Feito isso, volte na sua máquina mãe e tente o acesso ao servidor de banco de dados
```
esteban@meulamp:~$ exit
logout
Connection to 192.168.0.152 closed.
$ mysql -u root -p -h 192.168.0.152
Enter password: 
ERROR 2003 (HY000): Can't connect to MySQL server on '192.168.0.152' (61)
```
No meu caso, esse é o erro que dá. Isso está dizendo que o servidor não está ouvindo no IP indicado.

Assim que voltamos à VM e corrigimos a configuração do MariaDB
```
$ ssh esteban@192.168.0.152
esteban@meulamp:~$ sudo nano /etc/mysql/mariadb.conf.d/50-server.cnf
```
Procure pela linha que diz
```
bind-address = 127.0.0.1
```
e substitua pelo seguinte
```
bind-address = *
```
Agora reinicie o servidor
```
esteban@meulamp:~$ sudo systemctl restart mariadb
```
Volte à sua maquina mãe (gosto de chama-la assim… parece com ‘nave mãe’ ao final das contas somos como que alienigenas invadindo as VM da vida)
```
esteban@meulamp:~$ logout
Connection to 192.168.0.152 closed.
[estebandortta@Estebans-MacBook-Pro ~] mysql -u root -p -h 192.168.0.152
Enter password: 
ERROR 1130 (HY000): Host '192.168.0.142' is not allowed to connect to this MariaDB server
```
Repare que o erro mudou. Agora nos está dizendo que o nosso host (no caso 192.168.0.142 que é o IP da minha máquina mãe) está impedido de acessar.

Voltamos à VM e – usando nosso direito de acesso ao banco lá dentro – corrigimos isso assim:
```
$ ssh esteban@192.168.0.152
esteban@meulamp:~$ mysql -u root -p
```
E uma vez dentro do mysql fazemos assim:
```
MariaDB [(none)]> CREATE USER 'root'@'192.168.%' IDENTIFIED BY 'tr3co';
Query OK, 0 rows affected (0.00 sec)

MariaDB [(none)]> GRANT ALL PRIVILEGES ON *.* TO 'root'@'192.168.%';
Query OK, 0 rows affected (0.00 sec)

MariaDB [(none)]> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

MariaDB [(none)]> exit
```
Com isso criamos um novo usuário também chamado root mas com a senha tr3co que pode acessar este servidor desde qualquer micro da rede 192.168.x.x (Repare o uso do coringa ‘%’)

Voltamos à máquina mãe e testamos o acesso.
```
esteban@meulamp:~$ exit
logout
Connection to 192.168.0.152 closed.

$ mysql -u root -ps3nha -h 192.168.0.152
Welcome to the MariaDB monitor.  Commands end with ; or g.
Your MariaDB connection id is 7
Server version: 10.1.44-MariaDB-0ubuntu0.18.04.1 Ubuntu 18.04

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or 'h' for help. Type 'c' to clear the current input statement.

MariaDB [(none)]>
```
c. Alterando as configurações do usuário

É necessário que o usuário comum possa escrever na pasta /var/www/html

A forma mais fácil disso é fazer um sudo chmod -fR 0777 /var/www/html que é o análogo a colocar a saida do vaso direto no ralo do chuveiro. Funciona.

O certo mesmo é fazer com que o usuário comum (que tb é administrativo) consiga escrever na pasta /var/www/html

A primeira coisa a fazer é verificar em que grupo o apache2 trabalha. O seguinte comando faz isso:
```
esteban@meulamp:~$ ps aux | grep apache | awk '{ print $1 }' | grep -v "root|esteban" | uniq
```
No meu caso ele me devolve www-data. Para eu, usuário comum, poder escrever nas pastas desse grupo, devo pertencer ao mesmo.

Você pode verificar os direitos que seu usuário comum tem da seguinte forma:
```
esteban@meulamp:~$ id esteban
uid=1000(esteban) gid=1000(esteban) groups=1000(esteban),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),108(lxd)
```
Como você pode observar, o meu usuário comum não pertence ao grupo www-data. Adicionamos ele ao grupo com o seguinte comando:
```
esteban@meulamp:~$ sudo usermod -a -G www-data esteban
```
E podemos verificar com o comando id que de fato ele foi adicionado:
```
esteban@meulamp:~$ id esteban
uid=1000(esteban) gid=1000(esteban) groups=1000(esteban),4(adm),24(cdrom),27(sudo),30(dip),33(www-data),46(plugdev),108(lxd)
```
Só que se você for ver, ainda não pode criar arquivos na pasta /var/www/html:
```
esteban@meulamp:~$ touch /var/www/html/info.php 
touch: cannot touch '/var/www/html/info.php': Permission denied
```
A forma mais limpa de resolver isto é se apropriando da pasta /var/www/html:
```
esteban@meulamp:~$ sudo chown esteban /var/www/html
esteban@meulamp:~$ sudo chgrp www-data /var/www/html
```
Uma vez feito isso, você pode criar o arquivo /var/www/html/info.php com o seguinte conteúdo para comprovar o correto funcionamento e instalação de tudo:
```
<?php
 phpinfo();
?>
```
Proceda a testar a sua configuração solicitando ao apache que processe esse arquivo e mostre a saida na tela. Ou seja, navegue.
```
http://192.168.0.152/info.php
```
Se tudo ocorreu bem, tem que aparecer uma lista com as configurações atuais do apache, o php e o mysql.

Criando o primeiro programa

Bom, se tudo deu certo, é hora de criarmos o primeiro programa.

Mas para que o teste seja completo, vamos criar primeiro um banco de dados

esteban@meulamp:~$ mysql -u root -p

Welcome to the MariaDB monitor.  Commands end with ; or g.
Your MariaDB connection id is 7
Server version: 10.1.44-MariaDB-0ubuntu0.18.04.1 Ubuntu 18.04

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or 'h' for help. Type 'c' to clear the current input statement.

MariaDB [(none)]> create database meuTeste;
Query OK, 1 row affected (0.00 sec)

MariaDB [(none)]> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| meuTeste           |
| mysql              |
| performance_schema |
+--------------------+
4 rows in set (0.00 sec)

Uma vez criado o banco meuTeste (que por enquanto não tem tabelas) vamos escrever nosso primeiro programa.

esteban@meulamp:~$ nano /var/www/html/testar-conexao.php

Digitando o seguinte lá dentro:

<?php
 $con = mysqli_connect("localhost:3306", "root", "czyhnp");
 if ($con) {
   $db = mysqli_select_db("meuTeste")
   echo "Ok";
 } else {
   echo "Impossível conectar";
 }

Confirmamos que tudo esteja bem com ele usando o seguinte comando:

esteban@meulamp:~$ php -l /var/www/html/testar-conexao.php

Corrigimos os erros (se você estava copiando-colando tem um erro) usando o nano e o testamos pedindo para o apache2 usar seu pre-processador, passar para o php, este realizar o serviço, devolver seu resultado numa pipe textual, e o apache2 devolver para a conexão para que o navegador renderize isso perante nós. Simplificando: navegue

http://192.168.0.152/testar-conexao.php

Finalmente, reinicie

Com isso tudo pronto, reinice seu servidor e teste novamente para ver que tudo esteja ok
```
esteban@meulamp:~$ sudo reboot
```
Se os passos foram seguidos, tudo tem que continuar funcionando ok.

Lembre apenas que da próxima vez, vc pode levantar sua maquina virtual apenas usando a opção HeadLess
```
$ VBoxHeadless --startvm MeuLAMP
```

Criando um ambiente de desenvolvimento LAMP

Baixe a última versão estável do Ubuntu

Crie uma máquina virtual

a. Verifique se o local de armazenamento existe

b. Crie sua máquina virtual usando o seguinte comando:

c. Modifique ela para seus parâmetros mínimos.

d. Agora vamos adicionar um disco

e. Configuramos acesso remoto

f. Finalmente, inicie sua máquina para poder configura-la

Coisas a serem feitas durante a instalação

a. Escolha a partição que ocupa o disco inteiro e sem LVM.

b. Configure seu usuário.

b. Não esqueça de instalar o SSH (Ele vai oferecer OpenSSH logo após particionar o disco)

c. Deixe o restante como está.

d. Aguarde até o fim.

c. Caso a atualização der problemas escolha “Cancel Update and Reboot”

Coisas a serem feitas após a instalação

Configurando seu acesso via SSH

a. Acesse sua máquina virtual desde a linha de comandos da sua máquina. No meu caso fica assim:

b. Tem ou não um par de chaves na sua máquina mãe?

c. Copie sua chave pública para a VM

Instalando o LAMP

a. Instale o básico

b.Configure o acesso ao banco de dados

c. Alterando as configurações do usuário

Criando o primeiro programa

Finalmente, reinicie

Relacionado

Emulando Raspberry no Desktop

Baixe a última versão estável do Ubuntu

Crie uma máquina virtual

a. Verifique se o local de armazenamento existe

b. Crie sua máquina virtual usando o seguinte comando:

c. Modifique ela para seus parâmetros mínimos.

d. Agora vamos adicionar um disco

e. Configuramos acesso remoto

f. Finalmente, inicie sua máquina para poder configura-la

Coisas a serem feitas durante a instalação

a. Escolha a partição que ocupa o disco inteiro e sem LVM.

b. Configure seu usuário.

b. Não esqueça de instalar o SSH (Ele vai oferecer OpenSSH logo após particionar o disco)

c. Deixe o restante como está.

d. Aguarde até o fim.

c. Caso a atualização der problemas escolha “Cancel Update and Reboot”

Coisas a serem feitas após a instalação

Configurando seu acesso via SSH

a. Acesse sua máquina virtual desde a linha de comandos da sua máquina. No meu caso fica assim:

b. Tem ou não um par de chaves na sua máquina mãe?

c. Copie sua chave pública para a VM

Instalando o LAMP

a. Instale o básico

b.Configure o acesso ao banco de dados

c. Alterando as configurações do usuário

Criando o primeiro programa

Finalmente, reinicie

Compartilhe isso:

Relacionado

Emulando Raspberry no Desktop