One place for hosting & domains

      Coleções

      Como usar o módulo coleções em Python 3


      O autor selecionou a COVID-19 Relief Fund​​​​​ para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O Python 3 possui uma série de estruturas de dados integrados, incluindo tuplas, dicionários e listas. As estruturas de dados nos fornecem uma maneira de organizar e armazenar dados. O módulo collections (coleções) nos ajuda a preencher e manipular eficientemente as estruturas de dados.

      Neste tutorial, vamos abordar três classes no módulo collections para ajudá-lo a trabalhar com tuplas, dicionários e listas. Usaremos o namedtuples para criar tuplas com campos nomeados, defaultdict para agrupar informações de forma concisa em dicionários e deque para adicionar com eficiência elementos a qualquer um dos lados de um objeto do tipo lista.

      Para este tutorial, trabalharemos principalmente com um inventário de peixes que precisaremos modificar à medida que peixes são adicionados a ou removidos de um aquário fictício.

      Pré-requisitos

      Para aproveitar ao máximo este tutorial, é recomendável ter alguma familiaridade com os tipos de dados tupla, dicionário e lista. Tanto com suas sintaxes, quanto com como recuperar dados deles. Você pode revisar estes tutoriais para as informações básicas necessárias:

      Como adicionar campos nomeados a tuplas

      As tuplas em Python são uma sequência ordenada imutável, ou inalterável, de elementos. As tuplas são frequentemente usadas para representar dados colunares. Por exemplo, linhas de um arquivo CSV ou linhas de um banco de dados SQL. Um aquário pode acompanhar seu inventário de peixes como uma série de tuplas.

      Uma tupla de peixe individual:

      ("Sammy", "shark", "tank-a")
      

      Esta tupla é composta por três elementos string.

      Embora seja útil de algumas maneiras, esta tupla não indica com clareza o que cada um de seus campos representa. Na verdade, o elemento 0 é um nome, o elemento 1 é uma espécie e o elemento 2 é o tanque onde está localizado.

      Explicação dos campos da tupla de peixe:

      nome espécie tanque
      Sammy tubarão tanque-a

      Essa tabela deixa claro que cada um dos três elementos da tupla possui um significado claro.

      O namedtuple do módulo collections permite que você adicione nomes explícitos a cada elemento de uma tupla para tornar seus significados claros em seu programa Python.

      Vamos usar o namedtuple para gerar uma classe que nomeia com clareza cada elemento da tupla de peixe:

      from collections import namedtuple
      
      Fish = namedtuple("Fish", ["name", "species", "tank"])
      

      from collections import namedtuple dá ao seu programa Python acesso à função de fábrica namedtuple. A chamada de função namedtuple() retorna uma classe que está ligada ao nome Fish (peixe). A função namedtuple() possui dois argumentos: o nome desejado da nossa nova classe "Fish" e uma lista de elementos nomeados ["name", "species", "tank"] (“nome”, “espécie”, “tanque”).

      Podemos usar a classe Fish para representar a tupla de peixe de antes:

      sammy = Fish("Sammy", "shark", "tank-a")
      
      print(sammy)
      

      Se executarmos esse código, veremos o seguinte resultado:

      Output

      Fish(name="Sammy", species="shark", tank='tank-a')

      A sammy é instanciada usando a classe Fish. sammy é uma tupla com três elementos claramente nomeados.

      Os campos de sammy podem ser acessados pelo seu nome ou com um índice tradicional de tupla:

      print(sammy.species)
      print(sammy[1])
      

      Se executarmos essas duas chamadas de print, veremos o seguinte resultado:

      Output

      shark shark

      Acessar .species retorna o mesmo valor que quando acessa-se o segundo elemento de sammy usando [1].

      Usar o namedtuple do módulo collections torna seu programa mais legível, ao mesmo tempo em que mantém as propriedades importantes de uma tupla (que são imutáveis e ordenadas).

      Além disso, a função de fábrica namedtuple adiciona diversos métodos extras para as instâncias de Fish.

      Use ._asdict() para converter uma instância em um dicionário:

      print(sammy._asdict())
      

      Se executarmos print, você verá um resultado como o seguinte:

      Output

      {'name': 'Sammy', 'species': 'shark', 'tank': 'tank-a'}

      Chamar .asdict() em sammy retorna um dicionário que mapeia cada um dos três nomes de campo aos seus valores correspondentes.

      As versões do Python mais antigas que 3.8 podem gerar esta linha ligeiramente diferente como resultado. Você pode, por exemplo, ver um OrderedDict em vez do dicionário evidente mostrado aqui.

      Nota: em Python, os métodos com underline à esquerda são geralmente considerados “privados”. Métodos adicionais disponibilizados pelo namedtuple (como _asdict(), ._make(), ._replace(), etc), no entanto, são públicos.

      Como coletar dados em um dicionário

      Muitas vezes, pode ser útil coletar dados em dicionários Python. O defaultdict do módulo collections pode nos ajudar a reunir as informações em dicionários de maneira rápida e concisa.

      O defaultdict nunca provoca um KeyError. Se uma chave não estiver presente, o defaultdict simplesmente insere e retorna um valor de espaço reservado:

      from collections import defaultdict
      
      my_defaultdict = defaultdict(list)
      
      print(my_defaultdict["missing"])
      

      Se executarmos esse código, veremos um resultado como o seguinte:

      Output

      []

      O defaultdict insere e retorna um valor de espaço reservado ao invés de lançar um KeyError. Neste caso, especificamos o valor de espaço reservado como uma lista.

      Os dicionários regulares, por outro lado, lançarão um KeyError para chaves que estejam faltando:

      my_regular_dict = {}
      
      my_regular_dict["missing"]
      

      Se executarmos esse código, veremos um resultado como o seguinte:

      Output

      Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'missing'

      O dicionário regular my_regular_dict provoca um KeyError quando tentamos acessar uma chave que não está presente.

      O defaultdict comporta-se de maneira diferente de um dicionário regular. Em vez de criar um KeyError para uma chave que esteja faltando, o defaultdict chama o valor de espaço reservado com nenhum argumento para criar um novo objeto. Neste caso, o list() para criar uma lista vazia.

      Voltando ao nosso exemplo de aquário fictício, vamos supor que temos uma lista de tuplas de peixe representando o inventário de um aquário.

      fish_inventory = [
          ("Sammy", "shark", "tank-a"),
          ("Jamie", "cuttlefish", "tank-b"),
          ("Mary", "squid", "tank-a"),
      ]
      

      Existem três peixes no aquário — seus nomes, espécies e tanques são anotados nestas três tuplas.

      Nosso objetivo é organizar nosso inventário por tanque — queremos saber a lista de peixes presentes em cada tanque. Em outras palavras, queremos um dicionário que mapeie "tank-a" para ["Jamie, "Mary"], e "tank-b" para ["Jamie"].

      Podemos usar o defaultdict para agrupar peixes por tanque:

      from collections import defaultdict
      
      fish_inventory = [
          ("Sammy", "shark", "tank-a"),
          ("Jamie", "cuttlefish", "tank-b"),
          ("Mary", "squid", "tank-a"),
      ]
      fish_names_by_tank = defaultdict(list)
      for name, species, tank in fish_inventory:
          fish_names_by_tank[tank].append(name)
      
      print(fish_names_by_tank)
      

      Ao executarmos esse código, veremos o seguinte resultado:

      Output

      defaultdict(<class 'list'>, {'tank-a': ['Sammy', 'Mary'], 'tank-b': ['Jamie']})

      O fish_names_by_tank é declarado como um defaultdict, que utiliza-se do padrão para inserir o list() ao invés de lançar um KeyError. Como isso garante que todas as chaves em fish_names_by_tank apontarão para uma list (lista), temos a liberdade para chamar o .append() para adicionar nomes à lista de cada tanque.

      O defaultdict é útil aqui porque isso reduz as chances de KeyErrors inesperados. A redução dos KeyErrors inesperados significa que seu programa pode ser escrito com maior clareza e com menos linhas. Mais concretamente, o idioma defaultdict permite que você evite instanciar manualmente uma lista vazia para cada tanque.

      Sem o defaultdict, o loop for poderia ter ficado parecido com isto:

      More Verbose Example Without defaultdict

      ...
      
      fish_names_by_tank = {}
      for name, species, tank in fish_inventory:
          if tank not in fish_names_by_tank:
            fish_names_by_tank[tank] = []
          fish_names_by_tank[tank].append(name)
      

      O uso de apenas um dicionário regular (em vez de um defaultdict) significa que o loop for precisa sempre verificar se o tank indicado em fish_names_by_tank existe. Só depois de termos verificado que o tank já está presente em fish_names_by_tank, ou que acabou de ser inicializado com um [], é que podemos acrescentar o nome do peixe.

      O defaultdict pode ajudar a diminuir o código boilerplate ao preencher os dicionários, pois ele nunca causa um KeyError.

      Como usar o deque para adicionar elementos de maneira eficiente a qualquer lado de uma coleção

      As listas Python são uma sequência ordenada mutável, ou alterável, de elementos. O Python pode acrescentar elementos às listas constantemente (o comprimento da lista não tem efeito no tempo necessário para a inserção). Entretanto, inserir elementos no início de uma lista pode demorar mais — o tempo necessário aumenta à medida que a lista aumenta de tamanho.

      Em termos de notação O-grande, acrescentar um elemento a uma lista é uma operação de tempo constante O(1). A inserção de um elemento no início de uma lista, por outro lado, é mais lenta com um desempenho O(n).

      Nota: os engenheiros de softwares geralmente medem o desempenho de procedimentos usando algo conhecido como notação “O-grande”. Quando o tamanho de uma entrada não tem efeito no tempo necessário para se executar um procedimento, diz-se que a execução ocorre em tempo constante, ou O(1) (“O-grande de 1”). Assim como você aprendeu acima, o Python pode acrescentar elementos a listas com um desempenho temporal constante, também conhecido como O(1).

      Às vezes, o tamanho de uma entrada afeta diretamente o tempo necessário para se executar um procedimento. A inserção de um elemento no início de uma lista Python, por exemplo, é executada mais lentamente à medida que existam mais elementos na lista. A notação O-grande utiliza a letra n para representar o tamanho da entrada. Isso significa que a adição de itens no início de uma lista Python é executada em “tempo linear” ou O(n) (“O-grande de n”).

      De um modo geral, os procedimentos O(1) são mais rápidos que os procedimentos O(n).

      Somos capazes inserir elementos no início de uma lista Python:

      favorite_fish_list = ["Sammy", "Jamie", "Mary"]
      
      # O(n) performance
      favorite_fish_list.insert(0, "Alice")
      
      print(favorite_fish_list)
      

      Se executarmos isso, veremos um resultado como o seguinte:

      Output

      ['Alice', 'Sammy', 'Jamie', 'Mary']

      O método .insert(index, object) em lista permite que adicionemos "Alice" no início de favorite_fish_list. No entanto, deve-se notar que a inserção de um elemento no início de uma lista possui um desempenho O(n). À medida que o comprimento de favorite_fish_list cresce, o tempo necessário para inserir um peixe no início da lista crescerá proporcionalmente e demorará mais tempo.

      O deque (pronunciado como “deck”) do módulo collections é um objeto do tipo lista que nos permite inserir elementos no início ou final de uma sequência com performance temporal constante (O(1)).

      Insira um item no início de um deque:

      from collections import deque
      
      favorite_fish_deque = deque(["Sammy", "Jamie", "Mary"])
      
      # O(1) performance
      favorite_fish_deque.appendleft("Alice")
      
      print(favorite_fish_deque)
      

      Ao executarmos esse código, veremos o seguinte resultado:

      Output

      deque(['Alice', 'Sammy', 'Jamie', 'Mary'])

      Podemos instanciar um deque usando uma coleção preexistente de elementos, neste caso, uma lista de três nomes de peixes favoritos. Chamar o método appendleft de favorite_fish_deque nos permite inserir um item no início de nossa coleção com o desempenho O(1). Ter um desempenho O(1) significa que o tempo necessário para adicionar um item no início de favorite_fish_deque não aumentará, mesmo se favorite_fish_deque possuir milhares ou milhões de elementos.

      Nota: embora o deque adicione entradas no início de uma sequência mais eficientemente que uma lista, o deque não realiza todas as suas operações com maior eficiência que uma lista. Por exemplo, acessar um item aleatório em um deque possui um desempenho O(n), mas acessar um item aleatório em uma lista possui um desempenho O(1). Use o deque quando for importante inserir ou remover elementos de um dos lados de sua coleção rapidamente. Uma comparação completa do desempenho temporal está disponível na wiki do Python.

      Conclusão

      O módulo collections é uma parte poderosa da biblioteca padrão Python que permite que você trabalhe com dados de maneira concisa e eficiente. Este tutorial abordou três das classes disponibilizadas pelo módulo collections, incluindo namedtuple, defaultdict e deque.

      A partir daqui, utilize a documentação do módulo collection para aprender mais sobre outras classes e utilitários disponíveis. Para aprender mais sobre o Python em geral, consulte nossa série de tutoriais sobre Como programar em Python 3.



      Source link

      Como Instalar e Configurar um LEMP Stack usando Coleções de Software no CentOS 7


      O autor selecionou a Fundação do Software Apache para receber uma doação de $100 como parte do programa Write for DOnations.

      Introdução

      Uma pilha de software LEMP é um grupo de softwares de código aberto que são normalmente instalados juntos para permitir que um servidor hospede sites dinâmicos e aplicativos Web. Este termo é, na verdade, uma sigla que representa o sistema operacional Linux, com o servidor Web ENginx (que substitui o componente Apache de uma pilha LAMP). Os dados do site são armazenados em uma base de dados MySQL (usando MariaDB) e o conteúdo dinâmico é processado pelo PHP.

      Os componentes de pilha LEMP são, por vezes, instalados usando o repositório EPEL do CentOS 7. No entanto, este repositório contém pacotes desatualizados. Por exemplo, você não pode instalar nenhuma versão do PHP maior que a 5.4.16 do EPEL, embora este lançamento não tenha sido suportado por muito tempo. Para obter as versões mais recentes do software, é recomendado que você use Coleções de Software, também conhecidas como SCLs. Os SCLs são coleções de recursos do desenvolvedor fornecidos pela RedHat que permitem que você use várias versões do software no mesmo sistema sem afetar pacotes previamente instalados.

      Neste guia, você irá instalar uma pilha LEMP em um servidor do CentOS 7. O sistema operacional CentOS cuida do componente Linux. Você irá instalar o resto dos componentes usando o repositório de Coleções do Software e, em seguida, configurá-los para servir uma página Web simples.

      Pré-requisitos

      Antes de começar este tutorial, você deve ter o servidor CentOS 7 configurado seguindo o guia de configuração inicial do servidor CentOS 7, incluindo um usuário sudo que não seja root.

      Passo 1 — Ativando o Repositório de Coleções de Software

      Para obter acesso às SCLs para o CentOS, instalar o arquivo de liberação de Coleções de Software CentOS Linux:

      • sudo yum install centos-release-scl

      Veja a lista de pacotes SCL disponíveis usando o comando a seguir:

      • yum --disablerepo='*' --enablerepo='centos-sclo-rh' --enablerepo='centos-sclo-sclo' list available

      Para evitar quaisquer conflitos de sistema, os pacotes SCL são instalados no diretório /opt/rh. Isso permite que você, por exemplo, instale o Python 3.5 em uma máquina CentOS 7 sem remover ou interferir com o Python 2.7.

      Todos os arquivos de configuração para os pacotes SCL são armazenados na pasta correspondente dentro do diretório /etc/opt/rh/. Os pacotes SCL fornecem scripts de shell que definem as variáveis de ambiente necessárias para usar as aplicações incluídas, como PATH, LD_LIBRARY_PATH, e MANPATH. Estes scripts são armazenados no sistema de arquivos como /opt/rh/package-name/enable.

      Agora, você está pronto para começar a instalar os pacotes apresentados neste guia.

      Passo 2 — Instalando o Servidor Web Nginx

      Para mostrar páginas Web aos visitantes, vamos usar Nginx, um moderno e eficiente servidor Web.

      Instale Nginx usando o comando yum a seguir. Certifique-se de substituir o valor em destaque pela versão do Nginx que você quer instalar; a versão mais recente terá o número mais alto no nome do pacote (112 no momento em que este texto está sendo escrito):

      • sudo yum install rh-nginx112

      Assim que terminar a instalação, inicie o serviço Nginx:

      • sudo systemctl start rh-nginx112-nginx

      Certifique-se de que o Nginx está em execução através do comando systemctl status:

      • sudo systemctl status rh-nginx112-nginx

      Output

      ● rh-nginx112-nginx.service - The nginx HTTP and reverse proxy server Loaded: loaded (/usr/lib/systemd/system/rh-nginx112-nginx.service; disabled; vendor preset: disabled) Active: active (running) since Fri 2018-03-19 15:15:43 UTC; 1min 17s ago Main PID: 10556 (nginx) CGroup: /system.slice/rh-nginx112-nginx.service ├─10556 nginx: master process /opt/rh/rh-nginx112/root/usr/sbin/nginx ├─10557 nginx: worker process └─10558 nginx: worker process Mar 19 15:15:43 lemp-centos-222 systemd[1]: Starting The nginx HTTP and reverse proxy server... Mar 19 15:15:43 lemp-centos-222 nginx-scl-helper[10541]: nginx: the configuration file /etc/opt/rh/rh-nginx... ok Mar 19 15:15:43 lemp-centos-222 nginx-scl-helper[10541]: nginx: configuration file /etc/opt/rh/rh-nginx112/...ful Mar 19 15:15:43 lemp-centos-222 systemd[1]: Started The nginx HTTP and reverse proxy server. Hint: Some lines were ellipsized, use -l to show in full.

      Neste ponto, seu servidor pode estar vulnerável a um acesso não autorizado por usuários não autorizados. Para consertar isso, configure um firewall usando firewalld. Você pode precisar instalar primeiro o firewalld, o que pode ser feito com o comando a seguir:

      • sudo yum install firewalld

      Em seguida, inicie o serviço firewalld:

      • sudo systemctl start firewalld

      Então, adicione algumas regras no firewall para permitir o acesso SSH no seu servidor e as conexões HTTP e HTTPS no Nginx:

      • sudo firewall-cmd --permanent --add-service=ssh
      • sudo firewall-cmd --zone=public --permanent --add-service=http
      • sudo firewall-cmd --zone=public --permanent --add-service=https

      Recarregue o firewall para implementar as novas regras de firewall:

      • sudo firewall-cmd --reload

      Saiba mais sobre o firewalld em Como Configurar um Firewall Usando o FirewallD no CentOS 7.

      Com essas novas regras adicionadas no firewall, você pode testar se o servidor está funcionando acessando o nome do domínio do seu servidor ou endereço IP público no seu navegador Web.

      Se você não tiver um nome de domínio apontando no seu servidor e você não sabe o endereço IP público do seu servidor, você pode encontrá-lo digitando o seguinte no seu terminal:

      Digite o endereço IP obtido como resultado na barra de endereço do seu navegador, e você verá a página padrão de destino do Nginx:

      http://server_domain_or_IP
      

      Nginx default page

      Se você ver essa página, você instalou o Nginx com sucesso. Antes de continuar, habilite o Nginx para iniciar no boot usando o comando a seguir:

      • sudo systemctl enable rh-nginx112-nginx

      O servidor Nginx agora está instalado e você pode seguir para a instalação do software de banco de dados MariaDB.

      Passo 3 — Instalando MariaDB para Gerenciar os Dados do Site

      Agora que temos um servidor Web, é hora de instalar o MariaDB, um substituto para o MySQL, para armazenar e gerenciar os dados para seu site.

      Instale o MariaDB com o comando a seguir. Novamente, substitua o valor em destaque com o número de versão que você quer instalar, o número mais alto sendo a versão mais recente disponível (102, no momento em que o texto foi escrito):

      • sudo yum install rh-mariadb102

      Quando a instalação for concluída, inicie o serviço MariaDB com o comando a seguir:

      • sudo systemctl start rh-mariadb102-mariadb

      Com isso, o MariaDB está instalado e funcionando. No entanto, a configuração dele ainda não está completa.

      Para proteger a instalação, o MariaDB vem instalado com um script de segurança que te notifica para modificar algumas configurações padrão inseguras. Execute o script digitando:

      • source /opt/rh/rh-mariadb102/enable
      • mysql_secure_installation

      O aviso irá pedir a sua senha root atual. Uma vez que você acabou de instalar o MySQL, você provavelmente não terá um, então deixe ele em branco pressionando ENTER. Então a notificação irá perguntar se você quer definir uma senha root. Vá em frente e digite Y e siga as instruções:

      . . .
      Enter current password for root (enter for none):
      OK, successfully used password, moving on...
      
      Setting the root password ensures that nobody can log into the MariaDB
      root user without the proper authorization.
      
      Set root password? [Y/n] Y
      New password: password
      Re-enter new password: password
      Password updated successfully!
      Reloading privilege tables..
       ... Success!
      . . .
      

      Para o resto das perguntas, pressione a tecla ENTER em cada uma das notificações para aceitar os valores padrão. Isso irá remover alguns usuários anônimos e o banco de dados teste, desativará os logins remotos ao root, e carregará essas novas regras para que o MariaDB implemente imediatamente as alterações que fizemos.

      A última coisa a fazer é permitir que o MariaDB comece no boot. Use o comando a seguir para fazer isso:

      • sudo systemctl enable rh-mariadb102-mariadb

      Neste ponto, seu sistema de banco de dados está agora configurado e você pode seguir para a configuração do PHP no seu servidor.

      Passo 4 — Instalando e Configurando o PHP para Processamento

      Agora você tem o Nginx instalado para servir suas páginas e o MariaDB instalado para armazenar e gerenciar seus dados. No entanto, você ainda não tem nada instalado que possa gerar conteúdo dinâmico. É aqui que o PHP entra.

      Uma vez que o Nginx não contém o processamento nativo do PHP como outros servidores Web, você precisará instalar php-fpm, que significa “gerenciador de processos fastCGI”. Mais tarde, você irá configurar o Nginx para passar pedidos ao PHP para este software para processamento.

      Instale este módulo e pegue também um pacote auxiliar que irá permitir o PHP se comunicar com seu backend do banco de dados. A instalação irá puxar os arquivos principais e necessários do PHP. Faça isso digitando:

      • sudo yum install rh-php71-php-fpm rh-php71-php-mysqlnd

      Seu componente PHP agora está instalado, mas há uma ligeira alteração de configuração que você deve fazer para reforçar a segurança da sua instalação.

      Abra o arquivo principal de configuração php.ini com privilégios root:

      • sudo vi /etc/opt/rh/rh-php71/php.ini

      Neste arquivo, procure o parâmetro que define cgi.fix_pathinfo. Isso será comentado com um ponto-e-vírgula (;) e definido para “1” por padrão.

      Esta é uma configuração extremamente insegura porque ela diz ao PHP para tentar executar o arquivo mais próximo que ele puder descobrir se o arquivo PHP solicitado não puder ser encontrado. Isso basicamente permitiria que os usuários criassem pedidos PHP de uma maneira que lhes permitissem executar scripts que eles não deveriam ser autorizados a executar.

      Altere ambas essas condições descomentando a linha e definindo-a em “0” dessa forma:

      71/php.ini’>/etc/opt/rh/rh-php71/php.ini

      cgi.fix_pathinfo=0
      

      Salve e feche o arquivo quando você terminar (pressione ESC, digite :wq e então pressione Enter).

      A seguir, abra o arquivo de configuração php-fpm www.conf:

      • sudo vi /etc/opt/rh/rh-php71/php-fpm.d/www.conf

      Por padrão, este arquivo está configurado para funcionar com o servidor Apache. Uma vez que seu servidor tem o Nginx instalado nele, encontre as linhas que definem o user e group e que alteram os seus valores de “apache” para “nginx”:

      71/php-fpm.d/www.conf’>/etc/opt/rh/rh-php71/php-fpm.d/www.conf

      user = nginx
      group = nginx
      

      Então, salve e feche o arquivo.

      Em seguida, inicie seu processador PHP digitando:

      • sudo systemctl start rh-php71-php-fpm

      Então habilite o php-fpm para iniciar no boot:

      • sudo systemctl enable rh-php71-php-fpm

      Com isso, você instalou com sucesso o PHP no seu servidor. No entanto, ele ainda deve ser configurado para funcionar com outros softwares que você instalou para permitir que seu servidor sirva corretamente o conteúdo do seu site.

      Passo 5 — Configurando o Nginx para Usar o Processo PHP

      Neste ponto, você tem todos os componentes necessários para uma pilha LEMP instalados. A única alteração de configuração que você ainda precisa fazer é dizer ao Nginx para usar seu processador PHP para conteúdo dinâmico.

      Esta alteração de configuração é feita no nível de bloco do servidor ( os blocos do servidor são semelhantes aos hosts virtuais do Apache). Abra o arquivo padrão de configuração do bloco do servidor Nginx digitando:

      • sudo vi /etc/opt/rh/rh-nginx112/nginx/nginx.conf

      Descomente o bloco location ~.php$ (o segmento do arquivo que lida com pedidos PHP, encontrados no bloco server) e seu conteúdo removendo as cerquilhas (#) do começo de cada linha. Você também precisa atualizar a opção fastcgi_param para SCRIPT FILENAME $document_root$fastcgi_script_name. Isso informa o PHP do local da root do documento onde ele pode encontrar arquivos para processar.

      Após fazer as alterações necessárias, o bloco server estará assim:

      /etc/nginx/sites-available/default

      ...
      server {
          listen       80 default_server;
          listen       [::]:80 default_server;
          server_name  _;
          root         /opt/rh/rh-nginx112/root/usr/share/nginx/html;
      
          # Load configuration files for the default server block.
          include      /etc/opt/rh/rh-nginx112/nginx/default.d/*.conf;
      
          location / {
          }
      
          error_page 404 /404.html;
          location = /40x.html {
          }
      
          error_page 500 502 503 504  /50x.html;
          location = /50x.html {
          }
      
          # proxy the PHP scripts to Apache listening on 127.0.0.1:80
          #
          #location ~ .php$ {
          #    proxy_pass   http://127.0.0.1;
          #}
      
          # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
          #
          location ~ .php$ {
              root           html;
              fastcgi_pass   127.0.0.1:9000;
              fastcgi_index  index.php;
              fastcgi_param  SCRIPT_FILENAME $document_root$fastcgi_script_name;
              include        fastcgi_params;
          }
      
          # deny access to .htaccess files, if Apache's document root
          # concurs with nginx's one
          #
          #location ~ /.ht {
          #    deny  all;
          #}
      }
      ...
      

      Quando você fizer as alterações, você pode salvar o arquivo e sair do editor.

      Em seguida, teste seu arquivo de configuração à procura de erros de sintaxe executando os seguintes comandos:

      • source /opt/rh/rh-nginx112/enable
      • sudo nginx -t

      Se algum erro for reportado, volte e cheque novamente seu arquivo antes de continuar.

      Assim que seu arquivo de configuração estiver válido, recarregue o Nginx para implementar as alterações que você fez:

      • sudo systemctl reload rh-nginx112-nginx

      Agora que o Nginx, o PHP e o MariaDB foram instalados e configurados, tudo o que resta fazer é confirmar que a configuração da pilha LEMP pode servir corretamente os visitantes do seu site.

      Passo 6 — Criando um Arquivo PHP para Testar a Configuração

      Sua pilha LEMP está agora completamente configurada e você pode testá-la para validar que o Nginx é capaz de entregar corretamente arquivos .php para seu processador PHP. Isso é feito criando um arquivo PHP de teste em nossa root do documento.

      Abra um novo arquivo chamado info.php dentro da root do documento:

      • sudo vi /opt/rh/rh-nginx112/root/usr/share/nginx/html/info.php

      Adicione a seguinte linha ao novo arquivo. Este é um código PHP válido que irá retornar informações sobre seu servidor:

      112/root/usr/share/nginx/html/info.php’>/opt/rh/rh-nginx112/root/usr/share/nginx/html/info.php

      <?php phpinfo(); ?>
      

      Quando você terminar, salve e feche o arquivo. Então, visite esta página no seu navegador Web visitando o nome de domínio do seu servidor ou endereço IP público seguido por /info.php:

      http://server_domain_or_IP/info.php
      

      Você verá uma página Web que foi gerada pelo PHP com informações sobre seu servidor:

      PHP page info

      Se você ver uma página que se pareça com essa, o processamento PHP com o Nginx foi configurado com sucesso.

      Após verificar que o Nginx renderiza a página corretamente, é melhor remover o arquivo que você criou uma vez que ele pode de fato dar a usuários não autorizados algumas dicas sobre sua configuração que podem ajudá-los a tentar invadir. Você sempre pode regenerar este arquivo se você precisar dele mais tarde.

      Remova o arquivo digitando:

      • sudo rm /opt/rh/rh-nginx112/root/usr/share/nginx/html/info.php

      Com isso, você confirmou que todos os componentes da sua pilha LEMP estão instalados e configurados corretamente no seu servidor.

      Conclusão

      Agora você tem uma pilha LEMP totalmente configurada no seu servidor CentOS 7. Isso dá a você uma fundação muito flexível para fornecer conteúdo Web aos seus visitantes.

      Os SCLs também são usados para instalar várias versões de software e mudar entre elas. Você pode ver a lista de todas as coleções instaladas no sistema executando:

      Se estiver interessado, você pode encontrar mais informações sobre Coleções de Software no site oficial.



      Source link