Como configurar um domínio com LAMP – (Linux + Apache + MySQL + PHP)

Para quem está começando, algumas configurações de ambiente podem se mostrar realmente difíceis, uma das que tive bastante trabalho foi exatemente para poder rodar um projeto localmente utilizando PHP e por isso achei interessante compartilhar a forma que finalmente deu certo pra mim.

Existem algumas formas de se rodar um projeto localmente, um deles é o formato “LAMP”, que utiliza os softwares (PHP, Apache e MySQL). Após algumas tentativas esse foi o modelo que melhor funcionou para mim.

Instalando o Apache

Primeiro temos que instalar o Apache. Para isso abra seu terminal, para isso você pode procurar em aplicações e selecionar o terminal ou utilizar o atalho (CTRL + ALT + T) e digite os seguintes comandos:

$ sudo apt update
$ sudo apt install apache2

Ao terminar a instalação, confira se já é possível acessar o apache em seu navegador utilizando a url

http://127.0.0.1 ou http://localhost

Se a instalação ocorreu conforme esperado, você deverá ver essa imagem:

Instalando MySQL

O próximo passo é instalar um banco de dados, no nosso caso foi escolhido o mySQL. Para isso utilize seu terminal novamente e digite o seguinte comando:

$ sudo apt intall mysql-server

Quando a instalação for completada, ainda temos que configurar o MySQL para deixar mais seguro, para isso podemos rodar o comando:

$ sudo mysql_secure_installation

Isso trará uma série de perguntas no terminal, nos quais você poderá fazer algumas alterações nas opções de segurança da sua instalação do MySQL. O primeiro prompt perguntará se você deseja configurar o plug-in Validar senha, que pode ser usado para testar a força da sua senha do MySQL. Independentemente de sua escolha, o próximo prompt será definir uma senha para o usuário root do MySQL. Digite e confirme uma senha segura de sua escolha.

A partir daí, você pode pressionar Y e ENTER para aceitar os padrões para todas as perguntas subseqüentes. Isso removerá alguns usuários anônimos e o banco de dados de teste, desabilitar os logins raiz remotos e carregará essas novas regras para que o MySQL respeite imediatamente as alterações que você fez.

(opcional) Ajustes de autenticação e privilégios do usuário

O usuário root do MySQL é configurado para autenticar usando o plugin auth_socket por padrão, e não com uma senha. Isso permite maior segurança e usabilidade em muitos casos, mas também pode complicar as coisas quando você precisa permitir que um programa externo (por exemplo, phpMyAdmin) acesse o usuário.

Para usar uma senha para conectar-se ao MySQL como root, você precisará mudar seu método de autenticação de auth_socket para mysql_native_password. Para fazer isso, abra o prompt do MySQL no seu terminal:

$ sudo mysql

Em seguida, verifique qual método de autenticação cada uma das suas contas de usuário MySQL usa com o seguinte comando:

mysql> SELECT user,authentication_string,plugin,host FROM mysql.user;
Output
+——————+——————————————-+———————–+———–+
| user | authentication_string | plugin | host |
+——————+——————————————-+———————–+———–+
| root | | auth_socket | localhost |
| mysql.session | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | mysql_native_password | localhost |
| mysql.sys | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | mysql_native_password | localhost |
| debian-sys-maint | *CC744277A401A7D25BE1CA89AFF17BF607F876FF | mysql_native_password | localhost |
+——————+——————————————-+———————–+———–+
4 rows in set (0.00 sec)
Neste exemplo, você pode ver que o usuário root realmente se autentica usando o plugin auth_socket.

Para configurar a conta raiz para autenticar com uma senha, execute o seguinte comando ALTER USER. Certifique-se de alterar a senha para uma senha forte de sua escolha e observe que este comando altera a senha raiz que você definiu anteriormente:

mysql> ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

Em seguida, execute FLUSH PRIVILEGES, que instrui o servidor a recarregar as tabelas de concessão e colocar suas novas alterações em vigor:

mysql> FLUSH PRIVILEGES;

Para verificar se o método de autenticação foi alterado:

mysql> SELECT user,authentication_string,plugin,host FROM mysql.user;
Output
+——————+——————————————-+———————–+———–+
| user             | authentication_string                     | plugin                | host      |
+——————+——————————————-+———————–+———–+
| root             | *3636DACC8616D997782ADD0839F92C1571D6D78F | mysql_native_password | localhost |
| mysql.session    | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | mysql_native_password | localhost |
| mysql.sys        | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | mysql_native_password | localhost |
| debian-sys-maint | *CC744277A401A7D25BE1CA89AFF17BF607F876FF | mysql_native_password | localhost |
+——————+——————————————-+———————–+———–+
4 rows in set (0.00 sec)
Você pode ver neste exemplo de saída que o usuário root do MySQL agora é autenticado usando uma senha.

Depois de confirmar isso em seu próprio servidor, você pode sair do shell do MySQL:

mysql> exit
Nota 1: Se você tiver a autenticação de senha ativada para raiz, conforme descrito nos parágrafos anteriores, será necessário usar um comando diferente para acessar o shell do MySQL. A seguir, você executará seu cliente MySQL com privilégios regulares de usuário e você só obterá privilégios de administrador no banco de dados autenticando:
$ mysql -u root -p

Nota 2: Para eventualmente ver o status, parar ou reiniciar o mysql rode um dos comandos respectivamente:

$ systemctl status mysql.service
$ systemctl stop mysql.service
$ systemctl start mysql.service

Finalmente instalamos o MySQL Workbench, você pode rodar os comandos abaixo ou seguir a documentação oficial na página do mysql :

Primeiro é necessário fazer o download do pacote no repositório:

$ wget https://dev.mysql.com/get/mysql-apt-config_0.8.15-1_all.deb

Agora entre na pasta onde baixou o arquivo, geralmente em Downloads, e descompacte:

$ cd Downloads
$ sudo dpkg -i mysql-apt-config*.deb
$ sudo apt update

No momento em que você executar o comando acima, um shell interativo será aberto, use o botão TAB e selecione a opção OK, depois pressione o botão ENTER. Finalmente podemos instalar o MySQL Workbench

$ sudo apt install mysql-workbench-community

Instalando PHP e suas dependências

Aqui estão várias dependências do PHP que geralmente são necessárias para se utilizar o LAMP.

$ sudo apt install php autoconf bison build-essential curl gettext libcurl4-openssl-dev libedit-dev libicu-dev libjpeg-dev libmysqlclient-dev libonig-dev libpng-dev libpq-dev libreadline-dev libsqlite3-dev libssl-dev libxml2-dev libzip-dev openssl pkg-config re2c zlib1g-dev libapache2-mod-php php-mysql php-zip

Caso prefira uma instalação menor, instale ao menos as dependências a seguir

$ sudo apt-get install php libapache2-mod-php php-mysql

Após a instalação do PHP e as dependências, é necessário algumas configurações para que o apache procure primeiro por arquivos com extensão .php ao invés de .html.

Para fazer isso será necessário editar o arquivo dir.conf com privilégios de root

$ sudo nano /etc/apache2/mods-enabled/dir.conf

O arquivo dir.conf original se parecerá com isso:

<IfModule mod_dir.c>
    DirectoryIndex index.html index.cgi index.pl index.php index.xhtml index.htm
</IfModule>
/etc/apache2/mods-enabled/dir.conf

Tudo que precisa fazer é mover “index.php” (em destaque) para a primeira posição apoś “DirectoryIndex” como no exemplo a seguir.

<IfModule mod_dir.c>
    DirectoryIndex index.php index.html index.cgi index.pl index.xhtml index.htm
</IfModule>
/etc/apache2/mods-enabled/dir.conf

Quando terminar, salve e feche o arquivo pressionando CTRL + X. Confirme o salvamento digitando Y e pressione ENTER para verificar o local de salvamento do arquivo.

Depois disso, reinicie o servidor da web Apache para que suas alterações sejam reconhecidas. Faça isso digitando o seguinte:

$ sudo systemctl restart apache2

É possível também checar o status do apache usando systemctl

$ sudo systemctl status apache2

Configurando Virtual Hosts

Ao usar o servidor Apache, configure os hosts virtuais para poder acessar os projetos mais facilmente.

Para que o Apache sirva esse conteúdo, é necessário criar um arquivo host virtual com as diretivas corretas. Em vez de modificar o arquivo de configuração padrão localizado em /etc/apache2/sites-available/000-default.conf diretamente, criar um novo em /etc/apache2/sites-available/projeto.localhost.conf usando o comando cp:

$ sudo cp /etc/apache2/sites-available/000-default.conf /etc/apache2/sites-available/projeto.localhost.conf

Em seguida abra o arquivo com seu editor

$ sudo nano /etc/apache2/sites-available/projeto.localhost.conf

E cole o seguinte bloco de configuração, que é semelhante ao padrão, mas atualizado para o novo diretório e nome de domínio:


<VirtualHost *:80>
ServerAdmin [email protected]
DocumentRoot “/diretório_do_projeto/public

ServerName  projeto.localhost
<Directory />
Options FollowSymLinks
AllowOverride None
</Directory>
<Directory /diretório_do_projeto/public>
Options Indexes FollowSymLinks
Require all granted
AllowOverride All
</Directory>
</VirtualHost>
/etc/apache2/sites-available/projeto.localhost.conf

Observe que DocumentRoot e Directory (em destaque) para o caminho onde estão os arquivos do projeto e ServerName (em destaque) com o mesmo nome do arquivo .conf que está criando “projeto.localhost”.

É necessário habilitar o arquivo que acabou de criar utilizando o comando:

$ sudo a2ensite projeto.localhost.conf

Para testar se está tudo correto, pode utilizar o seguinte comando:

$ sudo apache2ctl configtest
Output
Syntax OK
Esse deve ser o resultado

Altere também o arquivo hosts:

$ sudo nano /etc/hosts

E cole o seguinte bloco de configuração, que é semelhante ao padrão, mas atualizado para o novo diretório e nome de domínio:

127.0.0.1 localhost
127.0.0.1 *.localhost
/etc/hosts

Também é necessário dar as permissões para acessar os diretórios do Path onde está o projeto

$ sudo chown -R $USER:$USER /diretório_do_projeto
$ sudo chmod -R 755 /diretório_do_projeto

Finalmente reinicie o Apache para implementar as mudanças:

$ sudo systemctl restart apache2

Testando PHP

Para testar se seu sistema está configurado corretamente para PHP, crie um script PHP muito básico chamado info.php. Para que o Apache encontre esse arquivo e o sirva corretamente, ele deve ser salvo no diretório raiz do projeto.

Crie o arquivo na raiz do projeto que você criou na etapa anterior e adicione o seguinte comando:

<?php
phpinfo();
?>
info.php

Quando terminar, salve e feche o arquivo.

Agora você pode testar se seu servidor da web é capaz de exibir corretamente o conteúdo gerado por esse script PHP. Para fazer isso, visite esta página no seu navegador.

O endereço que você deseja visitar é:

http://projeto.localhost/info.php

A página que você acessa deve ter a seguinte aparência:

Após testar, delete esse arquivo info.php.

Pronto, se tudo ocorreu como esperado, agora você poderá acessar seus projetos localmente.

Talvez seja possivel fazer essa mesma configuração de maneira mais enxuta, mas no meu caso, foi seguindo esses passos que deu certo 🙂

Parêntesis e chaves coloridas: um plugin que vai mudar sua vida

A rima não intencional no título é para falar do Bracket Pair Colorizer – ou de qualquer outro plugin que auxilie a identificar o que está fechando o que no seu código (parêntesis, chaves, colchetes).

Esta semana eu terminei de fazer um curso de NodeJS e estou colocando em prática duas das metas para 2019: trabalhando em um produto próprio e produzindo algo que vai para produção com NodeJS no back-end.

No javascript – mesmo evitando uma cadeia de callback hell – você ainda pode acabar se deparando com algo com uma estrutura parecida com isso:

({({({})})})

Descobri o plugin no tweet abaixo e ele faz exatamente o que parece:

Se você utiliza o VSCode, instalar é fácil:

ext install CoenraadS.bracket-pair-colorizer

Confira a página do Bracket Pair Colorizer. Se você utiliza outro editor recomendo procurar algo parecido – comecei a usar hoje e é muito prático.

Resolvido: Spotify só abre em fullscreen no Ubuntu

Parece ser um problema comum o Spotify “travar” no modo fullscreen no Ubuntu, sem dar acesso a taskbar.

Felizmente arrumar este problema do fullscreen é simples. Você deve:

  1. Encontrar o arquivo de configuração / preferências do Spotify
  2. Remover as referências as configurações de janela

Como encontrar meu arquivo de configuração do Spotify

Primeiro feche o Spotify. Depois vamos encontrar seu arquivo de configuração. Alguns fóruns que encontrei falam que o arquivo fica em ~/.config/spotify/prefs

No Ubuntu 18 o Spotify usa o snap, então para encontrar todos os arquivos de configuração fiz o seguinte:

find ~/snap/spotify/ -name prefs

Isto irá listar todos os arquivos “prefs” dentro do diretório. Para facilitar, você pode usar o seu editor e já abrir todos no editor:

find ~/snap/spotify/ -name prefs -execdir vscode {} \;

Agora é só procurar pelas ocorrências de app.window e remover estas linhas dos arquivos de configuração. Feito isso, salve os arquivos e pronto, seu spotify não abrirá mais no modo fullscreen.

Você também pode optar por apagar os arquivos de configuração – mas isto vai forçar um novo login quando você reiniciar o Spotify (e possivelmente perder qualquer outra configuração local que esteja salva nos arquivos de preferências).

Javascript – atribuição por referência x atribuição por valor

No Javascript os dados do tipo primitivos são atribuídos por valor e os objetos são atribuídos por referência.

O que são dados do tipo primitivos?

  • string
  • number
  • boolean
  • null
  • undefined
  • symbol

O que são considerados objetos?

  • Array
  • Funções
  • { }

O que significa passar os dados por valor?

Nos dados primitivos os dados são passados por valor, isso significa que é criado uma cópia e acontece uma nova alocação de memória para aquela informação.

let a = 1;
let b = a;
b += 1;

console.log(a); //1
console.log(b); //2

No exemplo acima, quando defino b é criado uma nova alocação de memória que copia o valor de a e atribui a minha nova variável b. Elas agora são independentes.

O que significa passar os dados por referência?

Quando falamos que os dados são passados por referência significa que irão apontar para o mesmo objeto na memória – o novo objeto será apenas uma referência ao caminho do objeto original na memória (pense como se fosse um atalho que você cria no seu desktop).

Isso acontece nos objetos:

let person = { name : 'Pacato'};
let person2 = person;
person2.name = 'Leon';

console.log(person.name); //Leon
console.log(person2.name); //Leon

Como person2 é apenas uma referência ao objeto alocado na memória como person, qualquer alteração em qualquer um deles será refletida no outro.

let arr = [1,2]; 
let arr2 =arr; 
arr2.push(3); 
console.log(arr); // [1, 2, 3]
console.log(arr2); // [1, 2, 3]

O mesmo ocorre com o array acima.

Como debugar NodeJS no VS Code?

Recentemente comecei a testar o VS Code, depois de alguns anos usando o Sublime Text (leia como abrir sublime no terminal (Linux) sem usar a sessão do terminal) e descobri que é possível fazer o debug de NodeJS do VS Code.

No momento que escrevi isso estou usando a V 1.29.1 do editor no Linux (Ubuntu), talvez algo possa ser um pouco diferente em outras versões ou plataformas.

O VS Code tem um botão de Debug na sidebar esquerda (de ícones), também pode ser ativado pelo menu View -> Debug ou ainda pelo atalho CTRL+SHIFT+D.

Neste debugger é possível fazer o start de uma aplicação/script em  NodeJS diretamente pelo VS Code.  Para isso antes é necessário criar um arquivo de configuração, clicando em Add Configuration (imagem abaixo).

Você define que é NodeJS e que a configuração será de Launch e o VS Code irá criar um arquivo launch.json na raiz do seu workspace, com o arquivo padrão. Você pode ter uma série de comandos diferentes para o debug, no mesmo arquivo – cada um representará uma opção no select de debug.

O editor disponibiliza vários modelos prontos de configurações, a Launch é a necessária para rodar e debugar um arquivo.

Com ela pronta, se você clicar em debugar (o ícone de “play” do printscreen acima) o VS Code irá executar seu arquivo e, por padrão, exibir no console interno do editor (debug console) qualquer resultado.

Ele também irá respeitar todos os breaking points que você marcar no arquivo. Você também tem uma aba de variáveis (na sidebar esquera do debug) que exibe tudo o que está disponível enquanto seu código roda.

Também é possível você acoplar o debugger do VS Code a um processo em NodeJS que já está rodando em sua máquina, para isso é necessário adicionar a configuração de “attach” no arquivo de config.

O vídeo abaixo (em inglês) explica um pouco dos processos básicos de debug com o editor.

Tabém vale a pena conferir a documentação sobre debug de NodeJS com o VS Code, lá tem detalhamento sobre as ocnfigurações possíveis para o Launch, protocolos utilizados, qual terminal utilizar (o do próprio VS Code ou externo), etc.