One place for hosting & domains

      Como Instalar o Servidor Web Apache no CentOS 7


      Introdução

      O servidor HTTP Apache é o servidor web mais utilizado no mundo. Ele fornece muitos recursos poderosos incluindo módulos dinamicamente carregáveis, suporte robusto a mídia, e integração extensiva com outros softwares populares.

      Neste guia, você instalará um servidor web Apache com virtual hosts em seu servidor CentOS 7.

      Pré-requisitos

      Você precisará do seguinte para concluir este guia:

      Passo 1 — Instalando o Apache

      O Apache está disponível nos repositórios de software padrão do CentOS, o que significa que você pode instalá-lo com o gerenciador de pacotes yum.

      Agindo como o usuário não-root, com privilégios sudo configurado nos pré-requisitos, atualize o índice de pacotes local httpd do Apache para refletir as alterações mais recentes do upstream:

      Depois que os pacotes forem atualizados, instale o pacote Apache:

      Após confirmar a instalação, o yum instalará o Apache e todas as dependências necessárias. Quando a instalação estiver concluída, você estará pronto para iniciar o serviço.

      Passo 2 — Verificando seu Servidor Web

      O Apache não inicia automaticamente no CentOS depois que a instalação é concluída. Você precisará iniciar o processo do Apache manualmente:

      • sudo systemctl start httpd

      Verifique se o serviço está sendo executado com o seguinte comando:

      • sudo systemctl status httpd

      Você verá um status active quando o serviço estiver em execução:

      Output

      Redirecting to /bin/systemctl status httpd.service ● httpd.service - The Apache HTTP Server Loaded: loaded (/usr/lib/systemd/system/httpd.service; enabled; vendor preset: disabled) Active: active (running) since Wed 2019-02-20 01:29:08 UTC; 5s ago Docs: man:httpd(8) man:apachectl(8) Main PID: 1290 (httpd) Status: "Processing requests..." CGroup: /system.slice/httpd.service ├─1290 /usr/sbin/httpd -DFOREGROUND ├─1291 /usr/sbin/httpd -DFOREGROUND ├─1292 /usr/sbin/httpd -DFOREGROUND ├─1293 /usr/sbin/httpd -DFOREGROUND ├─1294 /usr/sbin/httpd -DFOREGROUND └─1295 /usr/sbin/httpd -DFOREGROUND ...

      Como você pode ver nesta saída, o serviço parece ter sido iniciado com sucesso. No entanto, a melhor maneira de testar isso é solicitar uma página do Apache.

      Você pode acessar a página inicial padrão do Apache para confirmar que o software está sendo executado corretamente através do seu endereço IP. Se você não souber o endereço IP do seu servidor, poderá obtê-lo de algumas maneiras diferentes a partir da linha de comando.

      Digite isto no prompt de comando do seu servidor:

      Esse comando exibirá todos os endereços de rede do host, assim você receberá um retorno com alguns endereços IP separados por espaços. Você pode experimentar cada um em seu navegador para ver se eles funcionam.

      Alternativamente, você pode usar o curl para solicitar seu IP através do icanhazip.com, que lhe dará seu endereço IPv4 público como visto de outro local na internet:

      Quando você tiver o endereço IP do seu servidor, insira-o na barra de endereços do seu navegador:

      http://ip_do_seu_servidor
      

      Você verá a página padrão do Apache do CentOS 7:

      Default Apache page for CentOS 7

      Esta página indica que o Apache está funcionando corretamente. Ela também inclui algumas informações básicas sobre arquivos importantes do Apache e sobre localizações de diretórios. Agora que o serviço está instalado e em execução, você pode usar diferentes comandos systemctl para gerenciar o serviço.

      Passo 3 — Gerenciando o Processo do Apache

      Agora que você tem seu servidor web funcionando, vamos passar por alguns comandos básicos de gerenciamento.

      Para parar seu servidor web, digite:

      • sudo systemctl stop httpd

      Para iniciar o servidor web quando ele estiver parado, digite:

      • sudo systemctl start httpd

      Para parar e iniciar o serviço novamente, digite:

      • sudo systemctl restart httpd

      Se você estiver simplesmente fazendo alterações de configuração, o Apache pode muita vezes recarregar sem perder conexões. Para fazer isso, use este comando:

      • sudo systemctl reload httpd

      Por padrão, o Apache é configurado para iniciar automaticamente quando o servidor é inicializado. Se isso não é o que você deseja, desabilite esse comportamento digitando:

      • sudo systemctl disable httpd

      Para reativar o serviço para iniciar na inicialização, digite:

      • sudo systemctl enable httpd

      O Apache agora será iniciado automaticamente quando o servidor inicializar novamente.

      A configuração padrão do Apache permitirá que seu servidor hospede um único site. Se você planeja hospedar vários domínios em seu servidor, precisará configurar virtual hosts em seu servidor Apache.

      Passo 4 — Configurando Virtual Hosts (Recomendado)

      Ao utilizar o servidor web Apache, você pode usar virtual hosts (similares aos blocos do servidor no Nginx) para encapsular detalhes de configuração e hospedar mais de um domínio a partir de um único servidor. Neste passo você irá configurar um domínio chamado example.com, mas você deve substituí-lo por seu próprio nome de domínio. Para aprender mais sobre a configuração de um nome de domínio com a DigitalOcean, veja nossa Introdução ao DNS da DigitalOcean.

      O Apache no CentOS 7 tem um bloco de servidor ativado por padrão que é configurado para servir documentos a partir do diretório /var/www/html. Apesar disso funcionar bem para um único site, pode ficar difícil se você estiver hospedando vários sites. Em vez de modificar /var/www/html, você irá criar uma estrutura de diretórios dentro de /var/www para o site example.com, deixando /var/www/html no lugar como o diretório padrão a ser servido se uma requisição de cliente não corresponder a nenhum outro site.

      Crie o diretório html para example.com como segue, usando a flag -p para criar qualquer diretório pai que for necessário:

      • sudo mkdir -p /var/www/example.com/html

      Crie um diretório adicional para armazenar arquivos de log para o site:

      • sudo mkdir -p /var/www/example.com/log

      Em seguida, atribua a propriedade do diretório html com a variável de ambiente $USER:

      • sudo chown -R $USER:$USER /var/www/example.com/html

      Certifique-se de que seu web root ou pasta raiz para web tenha o conjunto de permissões padrão:

      • sudo chmod -R 755 /var/www

      Em seguida, crie uma página de exemplo index.html usando o vi ou seu editor favorito:

      • sudo vi /var/www/example.com/html/index.html

      Pressione i para alternar para o modo INSERT e adicione o seguinte exemplo de HTML ao arquivo:

      /var/www/example.com/html/index.html

      <html>
        <head>
          <title>Welcome to Example.com!</title>
        </head>
        <body>
          <h1>Success! The example.com virtual host is working!</h1>
        </body>
      </html>
      

      Salve e feche o arquivo pressionando ESC, digitando :wq e pressionando ENTER.

      Com o diretório do seu site e o arquivo de index de exemplo no lugar, você está quase pronto para criar os arquivos do virtual host. Os arquivos do virtual host especificam a configuração de seus sites independentes e informam ao servidor Apache como responder a várias solicitações de domínio.

      Antes de criar seus virtual hosts, você precisará criar um diretório sites-available para armazená-los. Você também criará o diretório sites-enabled que informa ao Apache que um virtual host está pronto para servir aos visitantes. O diretório sites-enabled conterá links simbólicos para os virtual hosts que queremos publicar. Crie ambos os diretórios com o seguinte comando:

      • sudo mkdir /etc/httpd/sites-available /etc/httpd/sites-enabled

      Em seguida, você dirá ao Apache para procurar por virtual hosts no diretório sites-enabled. Para fazer isso, edite o arquivo de configuração principal do Apache e adicione uma linha declarando um diretório opcional para arquivos de configuração adicionais:

      • sudo vi /etc/httpd/conf/httpd.conf

      Adicione esta linha ao final do arquivo:

      IncludeOptional sites-enabled/*.conf
      

      Salve e feche o arquivo quando terminar de adicionar essa linha. Agora que você tem seus diretórios de virtual host no lugar, você criará seu arquivo de virtual host.

      Comece criando um novo arquivo no diretório sites-available:

      • sudo vi /etc/httpd/sites-available/example.com.conf

      Adicione o seguinte bloco de configuração e altere o domínio example.com para o seu nome de domínio:

      /etc/httpd/sites-available/example.com.conf

      <VirtualHost *:80>
          ServerName www.example.com
          ServerAlias example.com
          DocumentRoot /var/www/example.com/html
          ErrorLog /var/www/example.com/log/error.log
          CustomLog /var/www/example.com/log/requests.log combined
      </VirtualHost>
      

      Isso dirá ao Apache onde encontrar diretamente a raiz que contém os documentos web publicamente acessíveis. Ele também informa ao Apache onde armazenar logs de erros e de solicitações para esse site específico.

      Salve e feche o arquivo quando terminar.

      Agora que você criou os arquivos do virtual host, você os habilitará para que o Apache saiba como servi-los aos visitantes. Para fazer isso, crie um link simbólico para cada virtual host no diretório sites-enabled:

      • sudo ln -s /etc/httpd/sites-available/example.com.conf /etc/httpd/sites-enabled/example.com.conf

      Seu virtual host agora está configurado e pronto para servir conteúdo. Antes de reiniciar o serviço Apache, vamos garantir que o SELinux tenha as políticas corretas em vigor para seus virtual hosts.

      Passo 5 — Ajustando Permissões do SELinux para Virtual Hosts (Recomendado)

      O SELinux está configurado para funcionar com a configuração padrão do Apache. Como você configurou um diretório de log personalizado no arquivo de configuração de virtual hosts, você receberá um erro se tentar iniciar o serviço Apache. Para resolver isso, você precisa atualizar as políticas do SELinux para permitir que o Apache grave nos arquivos necessários. O SELinux traz maior segurança ao seu ambiente CentOS 7, portanto, não é recomendado desativar completamente o módulo do kernel.

      Existem diferentes maneiras de definir políticas com base nas necessidades do seu ambiente, pois o SELinux permite que você personalize seu nível de segurança. Esta etapa abordará dois métodos de ajuste das políticas do Apache: universalmente e em um diretório específico. Ajustar políticas em diretórios é mais seguro e, portanto, é a abordagem recomendada.

      Ajustando Políticas do Apache Universalmente

      Definir a política do Apache universalmente dirá ao SELinux para tratar todos os processos do Apache de forma idêntica usando o booleano httpd_unified. Embora essa abordagem seja mais conveniente, ela não fornecerá o mesmo nível de controle que uma abordagem centrada em uma diretiva de arquivo ou diretório.

      Execute o seguinte comando para definir uma política universal para o Apache:

      • sudo setsebool -P httpd_unified 1

      O comando setsebool altera os valores booleanos do SELinux. A flag -P atualizará o valor de tempo de inicialização, fazendo com que essa mudança persista durante as reinicializações. httpd_unified é o booleano que irá dizer ao SELinux para tratar todos os processos do Apache como do mesmo tipo, então você habilitou-o com um valor de 1.

      Ajustando as Políticas do Apache em um Diretório

      Configurar individualmente as permissões do SELinux para o diretório /var/www/example.com/log lhe dará mais controle sobre suas políticas do Apache, mas também pode exigir mais manutenção. Como essa opção não está definindo políticas universalmente, você precisará definir manualmente o tipo de contexto para todos os novos diretórios de log especificados em suas configurações de virtual host.

      Primeiro, verifique o tipo de contexto que o SELinux deu ao diretório /var/www/example.com/log:

      • sudo ls -dZ /var/www/example.com/log/

      Este comando lista e imprime o contexto do SELinux do diretório. Você verá uma saída semelhante à seguinte:

      Output

      drwxr-xr-x. root root unconfined_u:object_r:httpd_sys_content_t:s0 /var/www/example.com/log/

      O contexto atual é httpd_sys_content_t, que informa ao SELinux que o processo do Apache só pode ler arquivos criados neste diretório. Neste tutorial, você irá alterar o tipo de contexto do diretório /var/www/example.com/log para httpd_log_t. Esse tipo permitirá ao Apache gerar e agregar arquivos de log da aplicação web:

      • sudo semanage fcontext -a -t httpd_log_t "/var/www/example.com/log(/.*)?"

      Em seguida, use o comando restorecon para aplicar essas mudanças e fazer com que elas persistam durante as reinicializações:

      • sudo restorecon -R -v /var/www/example.com/log

      A flag -R executa este comando recursivamente, o que significa que ele atualizará quaisquer arquivos existentes para usar o novo contexto. A flag -v imprimirá as mudanças de contexto feitas pelo comando. Você verá a seguinte saída confirmando as alterações:

      Output

      restorecon reset /var/www/example.com/log context unconfined_u:object_r:httpd_sys_content_t:s0->unconfined_u:object_r:httpd_log_t:s0

      Você pode listar os contextos mais uma vez para ver as alterações:

      • sudo ls -dZ /var/www/example.com/log/

      A saída reflete o tipo de contexto atualizado:

      Output

      drwxr-xr-x. root root unconfined_u:object_r:httpd_log_t:s0 /var/www/example.com/log

      Agora que o diretório /var/www/example.com/log está usando o tipo httpd_log_t, você está pronto para testar sua configuração de virtual host.

      Passo 6 — Testando o Virtual Host (Recomendado)

      Uma vez que o contexto do SELinux tenha sido atualizado com quaisquer dos métodos, o Apache poderá gravar no diretório /var/www/example.com/log. Agora você pode reiniciar o serviço Apache com sucesso:

      • sudo systemctl restart httpd

      Liste o conteúdo do diretório /var/www/example.com/log para ver se o Apache criou os arquivos de log:

      • ls -lZ /var/www/example.com/log

      Você verá que o Apache foi capaz de criar os arquivos error.log e requests.log especificados na configuração do virtual host:

      Output

      -rw-r--r--. 1 root root 0 Feb 26 22:54 error.log -rw-r--r--. 1 root root 0 Feb 26 22:54 requests.log

      Agora que você tem seu virtual host configurado e as permissões do SELinux atualizadas, o Apache agora servirá seu nome de domínio. Você pode testar isso navegando até http://example.com, onde você deve ver algo assim:

      Success! The example.com virtual host is working!

      Isso confirma que seu virtual host foi configurado e está servindo o conteúdo com êxito. Repita os Passos 4 e 5 para criar novos virtual hosts com permissões do SELinux para domínios adicionais.

      Conclusão

      Neste tutorial, você instalou e gerenciou o servidor web Apache. Agora que você tem seu servidor web instalado, você tem muitas opções para o tipo de conteúdo que você pode servir e as tecnologias que você pode usar para criar uma experiência mais rica.

      Se você quiser criar uma pilha ou stack de aplicação mais completa, consulte este artigo sobre como configurar uma pilha LAMP no CentOS 7.



      Source link

      How To Deploy a Go Web Application Using Nginx on Ubuntu 18.04


      The author selected the Tech Education Fund to receive a donation as part of the Write for DOnations program.

      Introduction

      Go is a general-purpose programming language that is gradually becoming one of the most popular web back-end programming languages. By focusing on simplicity, the designers of Go created a language that is both easy to learn and faster than many other languages for web applications, leveraging efficient features like its ability to handle multiple requests at a time due to its concurrency. Because of this, deploying a web application in Go will be useful to many back-end developers.

      Nginx is one of the most popular web servers in the world due to its lightweight resource usage and its reliability under load. Many of the largest and most highly trafficked sites on the internet depend on Nginx to serve their content. In deployment, Nginx is often used as a load balancer or a reverse proxy to increase security and make the application more robust. In conjunction with a Go web back-end, Nginx can serve up a powerful and fast web application.

      In this tutorial, you will build a Hello World web application in Go and deploy it on an Ubuntu 18.04 server using Nginx as a reverse proxy.

      Prerequisites

      To follow this tutorial, you will need the following:

      Additionally, in order to achieve a production-grade deployment of your Go web application, it’s important that you keep your server secure by installing a TLS/SSL certificate. This step is strongly encouraged. To secure your Go web application, follow How To Secure Nginx with Let’s Encrypt on Ubuntu 18.04 after Step 3 of this tutorial to obtain the free TLS/SSL certificate.

      Step 1 — Building the Go Web Application

      In this step, you will build a sample Go web application that displays Hello World at your_domain and greets the user at your_domain/greet/. If you would like to learn more about the basics of programming in Go, check out our How To Write Your First Program in Go article.

      First, create a new directory in your GOPATH directory to hold the source file. You can name the folder whatever you like, but this tutorial will use go-web:

      Following the file structure suggested in the prerequisite tutorial How To Install Go and Set Up a Local Programming Environment on Ubuntu 18.04, this will give your directory the path of ~/go/go-web.

      Next, run the following to change directory to your newly created folder in your GOPATH:

      Use nano or your preferred text editor to create a file named main.go, which will contain the source code for your web application:

      To create the functionality of the Hello World application, add the following Go code into the newly created main.go file:

      ~/go/go-web/main.go

      package main
      
      import (
          "fmt"
          "net/http"
      )
      
      func main() {
          http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
              fmt.Fprintf(w, "Hello World")
          })
      
          http.HandleFunc("/greet/", func(w http.ResponseWriter, r *http.Request) {
              name := r.URL.Path[len("/greet/"):]
              fmt.Fprintf(w, "Hello %sn", name)
          })
      
          http.ListenAndServe(":9990", nil)
      }
      

      Now let's go through what the preceding code snippet will do, starting from the first line.

      First, you wrote the entry point into your application:

      ~/go/go-web/main.go

      package main
      ...
      

      The package main tells the Go compiler to compile this file as an executable program instead of as a shared library.

      Next, you have the import statements:

      ~/go/go-web/main.go

      ...
      
      import (
          "fmt"
          "net/http"
      )
      ...
      

      This snippet imports the necessary modules required for this code to work, which include the standard fmt package and the net/http package for your web server.

      The next snippet creates your first route in the main function, which is the entry point of any Go application:

      ~/go/go-web/main.go

      ...
      func main () {
          http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
              fmt.Fprintf(w, "Hello World")
          })
        ...
      }
      ...
      

      A parent route / is created within func main, which will return the text Hello World when requested.

      The second route as shown in the following snippet accepts a URL parameter, in this case a name, to display accompanied by a greeting.

      ~/go/go-web/main.go

      ...
      func main () {
        ...
          http.HandleFunc("/greet/", func(w http.ResponseWriter, r *http.Request) {
              name := r.URL.Path[len("/greet/"):]
              fmt.Fprintf(w, "Hello %sn", name)
          })
      ...
      }
      ...
      

      This uses Go's URL.Path to store the value right after /greet/ and pass it down as the name from the URL parameter.

      Finally, you instantiate your server:

      ~/go/go-web/main.go

      ...
      func main () {
        ...
        http.ListenAndServe(":9990", nil)
      }
      

      The preceding snippet starts the server and exposes your application via port 9990 using Go's inbuilt http server.

      Once you are finished examining the code in main.go, save the file and quit your text editor.

      Next, build the binary executable of your application by running:

      The preceding command will compile main.go to produce an executable titled main.

      You have created your sample Go web application. Next, you will create a systemd unit file to keep your application running in the background even when you are not accessing your server.

      Step 2 — Creating a Systemd Unit File

      In this step, you will create a systemd unit file to keep your application running in the background even when a user logs out of the server. This will make your application persistent, bringing you one step closer to a production-grade deployment.

      First, create a new file in /lib/systemd/system directory named goweb.service using nano or you preferred text editor:

      • sudo nano /lib/systemd/system/goweb.service

      To set the parameters of the service, add the following snippet into the file.

      /lib/systemd/system/goweb.service

      [Unit]
      Description=goweb
      
      [Service]
      Type=simple
      Restart=always
      RestartSec=5s
      ExecStart=/home/user/go/go-web/main
      
      [Install]
      WantedBy=multi-user.target
      

      The ExecStart=/home/user/go/go-web/main variable specifies that the point of entry for this service is through the main executable located in the /home/user/go/go-web directory, where user is the server non-root sudo account username. Restart=always ensures that systemd will always try to restart the program if it stops. On the next line, RestartSec=5s sets a five-second wait time between restart attempts. WantedBy=multi-user.target specifies in what state your server will enable the service.

      Save and exit the file.

      Now that you've written the service unit file, start your Go web service by running:

      To confirm if the service is running, use the following command:

      • sudo service goweb status

      You'll receive the following output:

      Output

      ● goweb.service - goweb Loaded: loaded (/lib/systemd/system/goweb.service; disabled; vendor preset: enabled) Active: active (running) since Wed 2019-07-17 23:28:57 UTC; 6s ago Main PID: 1891 (main) Tasks: 4 (limit: 1152) CGroup: /system.slice/goweb.service └─1891 /home/user/go/go-web/main

      To learn more about working with systemd unit file, take a look at Understanding Systemd Units and Unit Files.

      Now that you have your application up and running, you can set up the Nginx reverse proxy.

      Step 3 — Setting Up a Reverse Proxy with Nginx

      In this step, you will create an Nginx server block and set up an Nginx reverse proxy to expose your application to the internet.

      First, change your working directory to the Nginx sites-available directory:

      • cd /etc/nginx/sites-available

      Create a new file with the name of the domain on which you wish to expose your application. This tutorial will use your_domain:

      Add the following lines into the file to establish the settings for your_domain:

      /etc/nginx/sites-available/your_domain

      server {
          server_name your_domain www.your_domain;
      
          location / {
              proxy_pass http://localhost:9990;
          }
      }
      

      This Nginx server block uses proxy_pass to serve the Go web application on your server's IP address indicated as localhost to make it run on port 9990. server_name indicates the domain name mapped to your IP address, in this case your_domain and www.your_domain.

      Next, create a symlink of this Nginx configuration in the sites-enabled folder by running the following command:

      • sudo ln -s /etc/nginx/sites-available/your_domain /etc/nginx/sites-enabled/your_domain

      A symlink is a shortcut of a file in another location. The newly created shortcut will always reference the original file to adjust to updates when edits are made to it. Nginx requires a copy of the configuration in both directories.

      Next, reload your Nginx configurations by running the reload command:

      To make sure that your deployment is working, visit http://your_domain in your browser. You will be greeted with a Hello World text string.

      Note: As mentioned in the Prerequisites section, at this point it is recommended to enable SSL/TLS on your server. This will make sure that all communication between the application and its visitors will be encrypted, which is especially important if the application asks for sensitive information such as a login or password. Follow How To Secure Nginx with Let's Encrypt on Ubuntu 18.04 now to obtain a free SSL certificate for Nginx on Ubuntu 18.04. After obtaining your SSL/TLS certificates, come back and complete this tutorial.

      You have now set up the Nginx reverse proxy to expose your application at your domain name, and secured your Go web application with SSL/TLS. In the next step, you will be testing your application over a secure connection.

      Step 4 — Testing the Application

      In this step, you will test your application over a secure connection to make sure everything is working.

      Open your preferred web browser, visit https://your_domain:

      Hello World Page Display

      You will receive a simple Hello World message. Receiving this message when using https:// in the URL indicates that your application is being served over a secure connection.

      Next, try visiting the second route https://your_domain/greet/your-name, replacing your-name with whichever name you want your app to greet:

      Greeting Page Display

      The application will return a simple greeting along with your-name, which is based on the parameter passed to the URL.

      Once you have received these results, you have successfully deployed your Go web application.

      Conclusion

      In this tutorial, you created a simple web application with Go using its standard libraries, set up a reverse proxy using Nginx, and used a SSL certificate on your domain to secure your app. To learn more about Go, check their official documentation. Also, you can look at our series How To Code in Go to learn more about programming in this efficient language.



      Source link

      How To Install the Apache Web Server on Debian 10


      Introduction

      The Apache HTTP server is the most widely-used web server in the world. It provides many powerful features including dynamically loadable modules, robust media support, and extensive integration with other popular software.

      In this guide, we’ll explain how to install an Apache web server on your Debian 10 server.

      Prerequisites

      Before you begin this guide, you should have a regular, non-root user with sudo privileges configured on your server. Additionally, you will need to enable a basic firewall to block non-essential ports. You can learn how to configure a regular user account and set up a firewall for your server by following our initial server setup guide for Debian 10.

      When you have an account available, log in as your non-root user to begin.

      Step 1 — Installing Apache

      Apache is available within Debian’s default software repositories, making it possible to install it using conventional package management tools.

      Let’s begin by updating the local package index to reflect the latest upstream changes:

      Then, install the apache2 package:

      After confirming the installation, apt will install Apache and all required dependencies.

      Step 2 — Adjusting the Firewall

      Before testing Apache, it's necessary to modify the firewall settings to allow outside access to the default web ports. Assuming that you followed the instructions in the prerequisites, you should have a UFW firewall configured to restrict access to your server.

      During installation, Apache registers itself with UFW to provide a few application profiles that can be used to enable or disable access to Apache through the firewall.

      List the ufw application profiles by typing:

      You will see a list of the application profiles:

      Output

      Available applications: AIM Bonjour CIFS . . . WWW WWW Cache WWW Full WWW Secure . . .

      The Apache profiles begin with WWW:

      • WWW: This profile opens only port 80 (normal, unencrypted web traffic)
      • WWW Cache: This profile opens only port 8080 (sometimes used for caching and web proxies)
      • WWW Full: This profile opens both port 80 (normal, unencrypted web traffic) and port 443 (TLS/SSL encrypted traffic)
      • WWW Secure: This profile opens only port 443 (TLS/SSL encrypted traffic)

      It is recommended that you enable the most restrictive profile that will still allow the traffic you've configured. Since we haven't configured SSL for our server yet in this guide, we will only need to allow traffic on port 80:

      You can verify the change by typing:

      You should see HTTP traffic allowed in the displayed output:

      Output

      Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere WWW ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) WWW (v6) ALLOW Anywhere (v6)

      As you can see, the profile has been activated to allow access to the web server.

      Step 3 — Checking your Web Server

      At the end of the installation process, Debian 10 starts Apache. The web server should already be up and running.

      Check with the systemd init system to make sure the service is running by typing:

      • sudo systemctl status apache2

      Output

      ● apache2.service - The Apache HTTP Server Loaded: loaded (/lib/systemd/system/apache2.service; enabled; vendor preset: enabled) Active: active (running) since Fri 2019-07-19 15:33:01 UTC; 4min 13s ago Docs: https://httpd.apache.org/docs/2.4/ . . . Jul 19 15:33:01 debssh systemd[1]: Starting The Apache HTTP Server... Jul 19 15:33:01 debssh apachectl[2791]: AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.1.1. Set the 'ServerName' directive global Jul 19 15:33:01 debssh systemd[1]: Started The Apache HTTP Server.

      As you can see from this output, the service appears to have started successfully. However, the best way to test this is to request a page from Apache.

      You can access the default Apache landing page to confirm that the software is running properly through your IP address. If you do not know your server's IP address, you can get it a few different ways from the command line.

      Try typing this at your server's command prompt:

      You will get back a few addresses separated by spaces. You can try each in your web browser to see if they work.

      An alternative is using the curl tool, which should give you your public IP address as seen from another location on the internet.

      First, install curl using apt:

      Then, use curl to retrieve icanhazip.com using IPv4:

      When you have your server's IP address, enter it into your browser's address bar:

      http://your_server_ip
      

      You should see the default Debian 10 Apache web page:

      Apache default page

      This page indicates that Apache is working correctly. It also includes some basic information about important Apache files and directory locations.

      Step 4 — Managing the Apache Process

      Now that you have your web server up and running, let's go over some basic management commands.

      To stop your web server, type:

      • sudo systemctl stop apache2

      To start the web server when it is stopped, type:

      • sudo systemctl start apache2

      To stop and then start the service again, type:

      • sudo systemctl restart apache2

      If you are simply making configuration changes, Apache can often reload without dropping connections. To do this, use this command:

      • sudo systemctl reload apache2

      By default, Apache is configured to start automatically when the server boots. If this is not what you want, disable this behavior by typing:

      • sudo systemctl disable apache2

      To re-enable the service to start up at boot, type:

      • sudo systemctl enable apache2

      Apache should now start automatically when the server boots again.

      When using the Apache web server, you can use virtual hosts (similar to server blocks in Nginx) to encapsulate configuration details and host more than one domain from a single server. In the following commands, replace your_domain with your own domain name. To learn more about setting up a domain name with DigitalOcean, see our Introduction to DigitalOcean DNS.

      Apache on Debian 10 has one server block enabled by default that is configured to serve documents from the /var/www/html directory. While this works well for a single site, it can become unwieldy if you are hosting multiple sites. Instead of modifying /var/www/html, let's create a directory structure within /var/www for our your_domain site, leaving /var/www/html in place as the default directory to be served if a client request doesn't match any other sites.

      Create the directory for your_domain as follows, using the -p flag to create any necessary parent directories:

      sudo mkdir -p /var/www/your_domain/html
      

      Next, assign ownership of the directory with the $USER environmental variable:

      • sudo chown -R $USER:$USER /var/www/your_domain/html

      The permissions of your web roots should be correct if you haven't modified your unmask value, but you can make sure by typing:

      • sudo chmod -R 755 /var/www/your_domain

      Next, create a sample index.html page using nano or your favorite editor:

      • nano /var/www/your_domain/html/index.html

      Inside, add the following sample HTML:

      /var/www/your_domain/html/index.html

      <html>
          <head>
              <title>Welcome to your_domain!</title>
          </head>
          <body>
              <h1>Success!  The your_domain virtual host is working!</h1>
          </body>
      </html>
      

      Save and close the file when you are finished.

      In order for Apache to serve this content, it's necessary to create a virtual host file with the correct directives. Instead of modifying the default configuration file located at /etc/apache2/sites-available/000-default.conf directly, let's make a new one at /etc/apache2/sites-available/your_domain.conf:

      • sudo nano /etc/apache2/sites-available/your_domain.conf

      Paste in the following configuration block, which is similar to the default, but updated for our new directory and domain name:

      /etc/apache2/sites-available/your_domain.conf

      <VirtualHost *:80>
          ServerAdmin admin@your_email_domain
          ServerName your_domain
          ServerAlias www.your_domain
          DocumentRoot /var/www/your_domain/html
          ErrorLog ${APACHE_LOG_DIR}/error.log
          CustomLog ${APACHE_LOG_DIR}/access.log combined
      </VirtualHost>
      

      Notice that we've updated the DocumentRoot to our new directory and ServerAdmin to an email that the your_domain site administrator can access. We've also added two directives: ServerName, which establishes the base domain that should match for this virtual host definition, and ServerAlias, which defines further names that should match as if they were the base name.

      Save and close the file when you are finished.

      Let's enable the file with the a2ensite tool:

      • sudo a2ensite your_domain.conf

      Disable the default site defined in 000-default.conf:

      • sudo a2dissite 000-default.conf

      Next, let's test for configuration errors:

      • sudo apache2ctl configtest

      You should see the following output:

      Output

      AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.1.1. Set the 'ServerName' directive globally to suppress this message Syntax OK

      Restart Apache to implement your changes:

      • sudo systemctl restart apache2

      Apache should now be serving your domain name. You can test this by navigating to http://your_domain, where you should see something like this:

      Apache virtual host example

      Step 6 – Getting Familiar with Important Apache Files and Directories

      Now that you know how to manage the Apache service itself, you should take a few minutes to familiarize yourself with a few important directories and files.

      Content

      • /var/www/html: The actual web content, which by default only consists of the default Apache page you saw earlier, is served out of the /var/www/html directory. This can be changed by altering Apache configuration files.

      Server Configuration

      • /etc/apache2: The Apache configuration directory. All of the Apache configuration files reside here.
      • /etc/apache2/apache2.conf: The main Apache configuration file. This can be modified to make changes to the Apache global configuration. This file is responsible for loading many of the other files in the configuration directory.
      • /etc/apache2/ports.conf: This file specifies the ports that Apache will listen on. By default, Apache listens on port 80 and additionally listens on port 443 when a module providing SSL capabilities is enabled.
      • /etc/apache2/sites-available/: The directory where per-site virtual hosts can be stored. Apache will not use the configuration files found in this directory unless they are linked to the sites-enabled directory. Typically, all server block configuration is done in this directory, and then enabled by linking to the other directory with the a2ensite command.
      • /etc/apache2/sites-enabled/: The directory where enabled per-site virtual hosts are stored. Typically, these are created by linking to configuration files found in the sites-available directory with the a2ensite. Apache reads the configuration files and links found in this directory when it starts or reloads to compile a complete configuration.
      • /etc/apache2/conf-available/, /etc/apache2/conf-enabled/: These directories have the same relationship as the sites-available and sites-enabled directories, but are used to store configuration fragments that do not belong in a virtual host. Files in the conf-available directory can be enabled with the a2enconf command and disabled with the a2disconf command.
      • /etc/apache2/mods-available/, /etc/apache2/mods-enabled/: These directories contain the available and enabled modules, respectively. Files in ending in .load contain fragments to load specific modules, while files ending in .conf contain the configuration for those modules. Modules can be enabled and disabled using the a2enmod and a2dismod command.

      Server Logs

      • /var/log/apache2/access.log: By default, every request to your web server is recorded in this log file unless Apache is configured to do otherwise.
      • /var/log/apache2/error.log: By default, all errors are recorded in this file. The LogLevel directive in the Apache configuration specifies how much detail the error logs will contain.

      Conclusion

      Now that you have your web server installed, you have many options for the type of content you can serve and the technologies you can use to create a richer experience.

      If you'd like to build out a more complete application stack, you can look at this article on how to configure a LAMP stack on Debian 10.



      Source link