Hai moitos páxinas web onde podemos comprar os dominios e xestionalos e tamén onde contratar un hosting. Descoñezo cales son os mellores. A modo de exemplo amosarei os servizos que emprego eu, cos que estou satisfeito.

1. Hosting.

Contrataremos un VPS. Trátase dunha máquina virtual sobre a que instalamos un sistema operativo gnu/Linux. No meu caso emprego os servizos de Digital Ocean

Aínda que da moitas opcións, nós só empregaremos un par delas:

a. Crear Droplet

 

Podemos escoller entre varios sistemas operativos:

Sen embargo, no noso caso crearemos unha unha máquina virtual Arch Linux a partir dunha imaxe, tal e como explicamos aquí: https://blog.atio.es/node/446

En canto ao tipo de máquina a escoller, quedaríame coa máis básica. Chega máis que suficiente para aprender ou para ter unha páxina Drupal. Se despois de tela online tedes moitas visitas, sempre a podedes mellorar, tanto en disco, ram ou número de cpu

E escollemos o datacenter. Entendo que o lóxico para nós é escoller un datacenter na UE. No meu caso escollino en Amsterdam 3. Non creo que haxa grandes diferencias entre uns de outros.

En canto á autentificación para acceder ao servidor, escollería a autentificación por SSH. Creades no voso equipo unha clave pública coa seguinte orde:

ssh-keygen

Se escollemos as opcións por defecto no cartafol do vos usuario /home/usuario, atoparedes un cartafol co nome .ssh e dentro del un par de ficheiros id_rsa e id_rsa.pub, unha clave privada e unha pública. Empregaremos a segunda. Para isto abrirémola cun programa como mousepad, gedit, kate, cat, etc e copiamos e pegamos o contido e dámoslle un nome mnemotécnico. No caso de traballar desde varios equipos sempre podemos engadir máis claves públicas.

 

Este par de claves, pública-privada podedes empregalas para cifrar outros documentos. No seu día explicara como cifrar documentos Libreoffice

Podemos activar as backups, para que faga unha copia automatizada cada semana, aínda que sempre podemos crear unha imaxe da máquina sempre que nos apeteza na opción Snapshots (unha vez accedemos á máquina) e tamén a opción Monitoring, que nos facilita unhas gráficas do uso de disco, ram ou cpu. Finalmente clic en Create Droplet. Con isto teremos o Droplet creado, coa súa ip, e xa podemos acceder ao mesmo por ssh

Para acceder ao mesmo, empregaremos o terminal, e neste exemplo escribiríamos:

ssh root@164.92.209.43

E entraríamos no terminal do doplet que acabamos de crear. Unha pantalla en negro, nada máis.

 

2. Dominio

O dominio é o nome da nosa páxina. No meu caso é atio.es

Eu son usuario de Dinahosting, unha empresa de Compostela. A miña experiencia con eles é moi boa, cunha atención ao cliente fenomenal. É unha mágoa que non teña uns prezos tan competitivos para os VPS

O primeiro que temos que facer é comprobar se o dominio que nos gusta está libre. Iso xa se fai na primeira páxina:

E no caso de estar libre, engadímolo ao carro:

Como observamos o prezo dun dominio .gal é máis de 4 veces máis caro que un .es, .com, etc.

Unha vez que teñamos pagado xa o podemos xestionar desde o panel de administración:

E pinchamos en Zonas DNS

 

Creamos os rexistros A que desexemos. Tamén creamos os subdominos que queiramos, como blog.atio.es, oaoa.atio.es, etc

 

Como sabedes, Arch Linux é unha distribución rolling release. Trátase dunha distribución que podemos actualizar indefinidamente sen necesidade de formatealo equipo. O primeiro que debemos ter e polo tanto un servidor cunha distribución Arch Linux. Con esta práctica aprenderemos a instalar un servidor LEMP que servirá para posteriormente instalar un Drupal, un Moodle ou un Wordpress, por exemplo.

Neste exemplo empregarei os servizos de https://digitalocean.com, escollendo un Droplet cunha imaxe de Arch.

Sen embargo, como non contemplan esta opción por defecto, debemos empregar unha imaxe unha imaxe openstack qcow. Atopámolo na seguinte servidor:

https://linuximages.de/openstack/arch/arch-openstack-LATEST-image-bootstrap.qcow2

E subimos a imaxe pinchando en Images > Custom Images > Import via URL

E unha vez que conclúa a subida, ceamos o Droplet

No apartado de Choose an image, pinchamos en Custom images

Seleccionamos a imaxe que acabamos de subir e escollemos as características do servidor que vamos empregar. Podemos escoller o máis económico se a intención é aprender ou publicar un blog con poucas visitas. Se pasado o tempo precisamos máis potencia no servidor, xa iremos incrementando as prestacións do mesmo. No meu caso escollín a rexión Amsterdam 3. Engadimos as chaves ssh para que poidamos acceder por ssh sen necesidade de introducir un contrasinal, e podemos renombrar o hostname con Arch, se preferimos un nome máis cómodo. Finalmente clic en Create Droplet

E despois duns segundos teremos o droplet coa súa ip pública creada. Abrimos o terminal e accedemos por ssh

Procedemos a actualizalo coas seguintes instrucións, pois veremos que aparecen problemas coas chaves públicas dalgún servidor

pacman-key --populate
pacman -Syyu --noconfirm
sudo pacman -S archlinux-keyring
pacman-key --populate
pacman -Syyu --noconfirm

E tamén instalamos unha serie de aplicacións que non farán falta durante a instalación de todo o servidor

pacman -Sy nano wget curl unzip git

E finalmente, se o desexamos, podemos crear un servizo que nos manteña actualizado o sistema operativo sen a nosa intervención:

sudo nano /etc/systemd/system/autoupdate.service

E pegamos o seguinte código:

[Unit]
 Description=Automatic Update
 After=network-online.target

[Service]
 Type=simple
 ExecStart=/usr/bin/pacman -Syuq --noconfirm
 TimeoutStopSec=180
 KillMode=process
 KillSignal=SIGINT

[Install]
 WantedBy=multi-user.target

E seguidamente editamos o seguinte ficheiro

sudo nano /etc/systemd/system/autoupdate.timer

E pegamos este outro código:

[Unit]
 Description= Actualización 10 minutos despois de reiniciar, e cada 60 minutes

[Timer]
 OnBootSec=10min
 OnUnitActiveSec=60min
 Unit=autoupdate.service

[Install]
 WantedBy=multi-user.target

Activamos e arrancamos o servizo autoupdate.timer:

sudo systemctl enable autoupdate.timer

sudo systemctl start autoupdate.timer

Con isto teremos o servidor sempre actualizado sen a nosa intervención.

Composer é a aplicación que normalmente empregaremos para a instalación de módulos en Drupal. Por exemplo, se quixéramos instalar o paquete IMCE empregaremos a seguinte instrución:

composer require 'drupal/imce:^2.4'

Para executar Composer é importante non facelo desde un usuario root. De feito o propio composer advirte desta circunstancia

Polo tanto o primeiro que faremos é crear  un usuario con dereitos sudo

1. Creación dun usuario sudo

Instalamos o paquete sudo e engadimos o usuario. No meu caso empregarei o usuario martin

 pacman -S sudo 

Creamos o usuario e engadímolo ao grupo wheel. A opción -m serve para que cree o cartafol /home/martin

useradd -m -G wheel -s /bin/bash martin

Editamos o ficheiro sudoers

nano /etc/sudoers

Descomentamos a liña

%wheel ALL=(ALL:ALL) ALL

Engadimos unha password ao usuario recén creado

passwd martin

E asignámoslle os privilexios de sudo

nano /etc/sudoers

##

## User privilege specification

##

root ALL=(ALL:ALL) ALL

martin ALL=(ALL:ALL) ALL 

Reiniciamos a máquina

reboot

2. Instalación de Composer

pacman -Sy composer

Comprobamos a versión instalada de composer

su martin
composer --versión

Neste caso o sistema imprime en pantalla a versión 2.3.5

3. Instalación de Drush

O comando Drush é moi interesante pois podemos limpar a caché, activar módulos, poñer en estado de mantemento a páxina e un longo etc. Vexamos como instalar Drush:

Seguimos no usuario martin e procedemos a instalar a versión 10 de Drush

composer global require drush/drush:10.x

Comprobamos en que ruta está instalado o Composer, executando a seguinte instrución:

composer config --global home

O sistema imprime en pantalla a seguinte ruta: /home/martin/.config/composer Escribimos en no ficheiro ~/.bashrc a ruta na que se atopa o executable do Drush, pero debemos substituír composer_path pola ruta obtida no paso anterior. echo 'export PATH="composer_path/vendor/bin:$PATH"' >> ~/.bashrc

echo 'export PATH="/home/martin/.config/composer/vendor/bin:$PATH"' >> ~/.bashrc

Para cargar a configuración gardada no .bashrc, executamos a seguinte orde:

source ~/.bashrc

E comprobamos a versión de Drush instalada no sistema

drush --version

E xa por último, para actualizar o drush executamos a seguinte orde:

composer global update drush/drush

 

Pasos previos:

1. Instalación do servidor LEMP: https://blog.atio.es/node/441

2. Instalación de Drupal9: https://blog.atio.es/node/442

Polo tanto xa dispoñemos un Drupal 9 instalado nun servidor LEMP. Configuremos o Drupal xa instalado para que lle dea soporte a varios dominios, é dicir para ter varias páxinas web que empregan os módulos, o core do Dupral principal, ocupando menos espazo e coa vantaxe de que só precisamos actualizar un só sitio.

Paso 1. Configuración dos dominios. Dirixímonos ao noso proveedor de nomes de dominio, no meu caso dinahosting.com e creamos varios subdominios que apunten á ip do servidor, neste caso á ip 164.92.209.43

Fago varios Rexistro tipo A, aínda que neste exemplo só imos empregar d.atio.es, pero podo facer tantos como páxinas queira ter no multisite

d.atio.es -> 164.92.209.43

Paso 2. Accedemos por ssh ao servidor e creamos os seguintes cartafoles dentro do cartafol  blog, que é o cartafol onde instalamos o drupal principal e creamos e asignamos os permisos necesarios para cada un dos subcartafoles

mkdir -p /srv/http/blog/sites/atio/files/translations
chmod -R 777 /srv/http/blog/sites/atio/files
cp /srv/http/blog/sites/default/default.settings.php  /srv/http/blog/sites/atio/settings.php
chmod 777 /srv/http/blog/sites/atio/settings.php

Paso 3. Copiamos o ficheiro example.sites.php a sites.php. Este ficheiro é o encargado de redirixir o navegador a unha ruta interna e concreta de Drupal, en función do nome de dominio que faga a chamada. Vexamos como se configura:

cp /srv/http/blog/sites/example.sites.php /srv/http/blog/sites/sites.php

nano /srv/http/blog/sites/sites.php

E engadimos un conxunto de liñas necesarias para redixir a búsqueda dos dominios aos distintos cartafoles. No noso caso só estamos configurando o dominio d.atio.es para que apunte ao cartafol /srv/http/blog/sites/atio/, polo tanto deixámolo do seguinte xeito:

$sites['d.atio.es'] = 'atio';

Paso 4. Configuramos o ficheiro do virtual host.

cd /etc/nginx/sites-avaliable

Descargamos o ficheiro default, se non o temos xa descargado neste cartafol

wget https://atio.es/pub/vhost_default

Copiamos no vhost_default c nome mnmoténico da configuración da páxina que estamos configurando

cp default atio

E editámolo e configurámolo

nano atio

a. Cambiamos o root

root /srv/http;   
por:
root /srv/http/blog;

b.  O server_name

server_name _;
por:
server_name d.atio.es;

c. Se desexamos empregar a versión php 7.4 en vez da 8.1, cambiamos a liña fastcgi_pass unix:/run/php-fpm/php-fpm.sock; por esta fastcgi_pass unix:/run/php-fpm7/php-fpm.sock;

# pass PHP scripts to FastCGI server 
       #
       location ~ \.php$ {
               include fastcgi.conf;
               # With php-fpm (or other unix sockets):
               fastcgi_pass unix:/run/php-fpm/php-fpm.sock;
       #       # With php-cgi (or other tcp sockets):
       #       fastcgi_pass 127.0.0.1:9000;
       }

por:

 # pass PHP scripts to FastCGI server
        #
        location ~ \.php$ {
                #include snippets/fastcgi-php.conf;
                include fastcgi.conf;

                # With php-fpm (or other unix sockets):
                fastcgi_pass unix:/run/php-fpm7/php-fpm.sock;
        #       # With php-cgi (or other tcp sockets):
        #       fastcgi_pass 127.0.0.1:9000;
        }

Paso 5. Creamos un enlace simbólico ao cartafol sites-enabled, comprobamos a sintaxis da configuración e recargamos o nginx

sudo ln -s /etc/nginx/sites-available/atio /etc/nginx/sites-enabled/
nginx -t
nginx -s reload

Paso 6. Xeramos os certificados do dominio d.atio.es coa ferramenta Certbot

certbot --nginx

e o sistema pregúntanos para que dominios queremos activar https. Neste caso escollemos o segundo d.atio.es, inserimos un 2, polo tanto.

Paso 7. Accedemos co navegador no dominio d.atio.es e procedemos a instalar este sitio que acabamos de configurar que a súa vez está dentro dun Drupal principal.

E configuramos unha nova base de datos para este novo sitio

 

E cando remate teremos o novo sitio funcionando. Non podemos esquecer restrinxir o modo escritura no ficheiro settings.php do espazo que acabamos de crear.

chmod 644 /srv/http/blog/sites/atio/settings.php

E tal e como explicamos aquí, para protexer o servidor contra os ataques HTTP HOST Header:

nano /srv/http/blog/sites/default/settings.php

 $settings['trusted_host_patterns'] = [
    '^d.atio\.es$',
    '^www\.d.atio\.es$'
  ];

Repetindo o proceso, podemos ter cantos espazos web como desexemos.
 

 

 

 

 

 

 

Debemos de dispoñer dun servidor LEMP. Na entrada https://blog.atio.es/node/441, podemos seguir un procedemento para a instalación dun servidor LEMP en Arch Linux. E, coa configuración seguida na entrada mencionada, procedemos a instalar un Drupal 9

Aproveitando a explicación dada na nova https://blog.atio.es/node/441, creamos un ficheiro de configuración en /etc/nginx/sites-available, que lle ordena ao servidor abrir os contidos na ruta /srv/http/blog. Podemos visualizar a configuración editando o ficheiro:

nano /etc/nginx/sites-available/blog

Ou tamén podes descargalo na seguinte url: http://atio.es/pub/blog

Antes de nada borramos todos os ficheiros que teñamos dentro do cartafol blog. Mantemos o cartafol phpmyadmin

rm /srv/http/blog/*

Dirixímonos á ruta /srv/http, e descargamos o drupal

cd /srv/http

wget https://www.drupal.org/download-latest/zip

E descargamos un ficheiro comprimido co nome de zip. Descomprimímolo

unzip zip

E movemos todo o contido do cartafol drupal-9.3.12 ao cartafol blog

mv  /srv/http/drupal-9.3.12/* /srv/http/blog

Procedemos a crear dous cartafoles necesarios para descargar a tradución no Drupal e dámoslle permisos de escritura:

mkdir /srv/http/blog/sites/default/files

mkdir /srv/http/blog/sites/default/files/translations

chmod -R 777 /srv/http/blog/sites/default/files

E facemos unha copia do ficheiro default.settings.php co nome de settings.php. Dámoslle tamén permisos de escritura o ficheiro

cp /srv/http/blog/sites/default/default.settings.php /srv/http/blog/sites/default/settings.php

chmod 777  /srv/http/blog/sites/default/settings.php

Ademais é intersante actualizar os módulos do Drupal antes de proceder coa instalación. Isto podemos facelo coa ferramenta composer, que será a que empregaremos para a instalación dos diferentes módulos. Nesta nova podes ver como se instala: https://blog.atio.es/node/444

Abrimos o navegador e neste exemplo abrimos a ruta https://d.blog.atio.es e procedemos a instalar o Drupal

Escollemos o idioma e clic en Save and continue. Na seguinte ventana escollemos a instalación estándar e clic en Gardar e continuar

Inserimos un nome dunha base de datos para gardar os datos da aplicación, un nome de usuario e un contrasinal. Neste caso empreguei o usuario root e o contrasinal que configurei na nova anterior, coa axuda instrución:

mysqladmin --user=root password "contrasinal"

E ao premer en Gardar e continuar, comeza a instalar

Configuramos a información do sitio

E unha vez que premamos en Gardar e  continuar, debemos quitarlle os permisos de escritura ao ficheiro settings.php

chmod 644 /srv/http/blog/sites/default/settings.php

Sen embargo nos informes de estado que atopamos na ruta informes > Informes de estado, aparece o seguinte erro:

Para resolvelo editamos o ficheiro settings.php e ao rematar a sección Trusted host configuration, engadimos as seguintes liñas:

nano /srv/http/blog/sites/default/settings.php

  $settings['trusted_host_patterns'] = [
    '^d.blog.atio\.es$',
    '^www\.d.blog.atio\.es$' 
  ];

Se todo vai ben, no apartado informes > Informes de estado visualizaremos o seguinte cadro resumo:

1. Instalación e configuración do servidor NGINX

O Nginx é un servidor web moi lixeiro e cun alto rendemento. Ademais, aínda que nesta nova non o veremos, permite a creación dun proxy inverso ou un balanceador de carga. Vexamos como se instala

pacman -S nginx-mainline

E creamos o servizo para que se inicie nginx cando se reinicie o servidor

systemctl enable --now nginx

Se accedemos co navegador podemos observar que xa funciona o noso servidor, dándonos unha mensaxe de benvida

Co obxectivo de evitar un erro, que se imprime na pantalla coa seguinte lenda: "could not build optimal types_hash, you should increase either types_hash_max_size: 1024...", editamos o ficheiro nginx.conf

nano /etc/nginx/nginx.conf

E no apartado http, engadimos as seguintes liñas ao principio:

http {
    client_max_body_size 100M;
    types_hash_max_size 4096;
    server_names_hash_bucket_size 128;

 

2. Configuración dos VHOST

Accedemos ó cartafol de configuración do nginx

cd /etc/nginx

E creamos dous subcartafoles:

mkdir sites-available

mkdir sites-enabled

E dentro destes cartafoles crearemos os ficheiros de configuración que redirixan o servidor a outro cartafol do servidor, pero empregando uns servizos definidos como pode ser unha versión específica de php. Para isto descargamos no cartafol sites-available o seguinte ficheiro que nos servirá de axuda:

cd sites-available

wget https://atio.es/pub/default

Creamos  o ficheiro co nome blog. Os nomes dos ficheiros de configuración poden ter calquera denominación.

cp default blog

cp default oaoa

Configuramos o primeiro, o ficheiro blog. Pasamos a editalo:

nano blog

E procedemos a facer os seguintes cambios:

1º cambio, eliminamos default_server das dúas liñas seguintes:

server {
 listen 80 default_server;
 listen [::]:80 default_server;

por:

server {
 listen 80;
 listen [::]:80;

2º cambio. Definimos a ruta na cal imos gardar a páxina web. Polo tanto mudamos:

root /srv/http;

por:

root /srv/http/blog;

3º cambio. Definimos o nome do dominio mediante o cal queremos acceder á páxina web. Polo tanto cambiamos de:

server_name _;

por:

server_name d.blog.atio.es;

Gardamos o ficheiro e creamos un enlace simbólico no cartafol sites-enabled do ficheiro blog

sudo ln -s /etc/nginx/sites-available/blog /etc/nginx/sites-enabled/

Abrimos o ficheiro nginx.conf

nano /etc/nginx/nginx.conf

e engadimos ao final do mesmo, e antes da chave de peche }, é dicir, a penúltima liña, a seguinte instrución:

include /etc/nginx/sites-enabled/*;

}

gardamos os cambios e comprobamos a sintaxis:

nginx -t

E se todo foi ben imprimirase en pantalla a seguinte mensaxe:

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Cargamos a configuración, para que sexa tida en conta polo servidor e reiniciamos o servizo

nginx -s reload

systemctl reload nginx

E seguidamente dirixímonos á ruta pública por defecto do servidor e creamos o cartafol no que colocaremos a páxina web:

cd /srv/http

mkdir blog

Entramos dentro do cartafol blog e creamos un ficheiro index.html

cd blog

nano index.html

E engadimos por exemplo este contido:

Ola desde Blog!

Ademais, no noso proveedor do dominio temos que configurar o dominio. Neste exemplo, o dominio d.blog.atio.es en que apuntar á ip 164.92.209.43. Teremos en conta que o cambio non é instantáneo, e pode demorar uns minutos.

E xa por último, se accedemos co noso navegador ao dominio d.blog.atio.es, ábrese a páxina que aloxamos dentro do cartafol /srv/http/blog

3. Solicitar os certificados Let's Encrypt coa utilidade Certbot

Como podemos observar na imaxe anterior, aparece un candado tachado. Isto significa que a comunicación co servidor non é segura, é dicir non é cifrada e ademais o navegador non nos dá garantía de que a páxina sexa que di que é. Hai un servizo chamado Let's Encrypt mediante o cal podemos obter certificados gratuítos. Para a comunicación e xestión deste servizo empregamos o programa Certbot. Procedemos a instalalo e creamos os certificados

sudo pacman -S certbot-nginx
sudo certbot --nginx

E neste exemplo crea o certificado para o dominio d.blog.atio.es. Se abrimos o dominio no navegador, aínda que non engadíranos o protocolo seguro https, seremos redixidos ao protocolo seguro e aparece o candado

Sen embargo debemos crear un servizo para revisar e renovar o certificado.

nano /etc/systemd/system/certbot.service


[Unit]
Description=Let's Encrypt renewal
After=network-online.target

[Service]
Type=simple
ExecStart=/usr/bin/certbot renew --quiet --agree-tos
TimeoutStopSec=180
KillMode=process
KillSignal=SIGINT

[Install]
WantedBy=multi-user.target

e seguidamente:

nano /etc/systemd/system/certbot.timer

[Unit]
Description=Twice daily renewal of Let's Encrypt's certificates

[Timer]
OnCalendar=0/12:00:00
RandomizedDelaySec=1h
Persistent=true

[Install]
WantedBy=timers.target

E habilitamos e cargamos o servizo certbot.timer

sudo systemctl enable certbot.timer
sudo systemctl enable certbot.service

sudo systemctl start certbot.timer
sudo systemctl start certbot.service

4. SERVIDOR PHP

Coa axuda do paquete php-fpm, podemos instalar varias versións de php no propio equipo. E os ficheiros de configuración vhost de nginx (/etc/nginx/sites-available), decidimos con que versión executar cada unha das páxinas web. Por exemplo, podemos executar o Drupal cunha versión de php 8 e un Moodle cunha versión php 7.4

sudo pacman -S php-fpm
sudo systemctl enable php-fpm
sudo systemctl start php-fpm

E configuramos /etc/nginx/nginx.conf para cando accedamos a través da ip no navegador e despois da zona de PHP Script pegamos o seguinte código:

location ~ \.php$ {
 fastcgi_pass unix:/var/run/php-fpm/php-fpm.sock;
 fastcgi_index index.php;
 root /srv/http;
 include fastcgi.conf;
}

Comprobamos a sintaxe do da configuración e recargamos o nginx

nginx -t
nginx -s reload

Creamos un ficheiro info.php en /srv/http

nano /srv/http/info.php

e engadimos o seguinte contido:

<?php
 phpinfo();
 ?>

Abrimos o navegador e comprobamos que funciona o servidor php ao inserir a ruta http://164.92.209.43/info.php

Configuramos agora o ficheiro blog situado en /etc/nginx/sites-available

nano /etc/nginx/sites-available/blog

Dirixímonos á sección  php e descomentamos unhas cantas liñas e configuramos correctamente a ruta na que se atopa o php-fp.sock

# pass PHP scripts to FastCGI server
#
#location ~ \.php$ {
#       include fastcgi.conf;
#       # With php-fpm (or other unix sockets):
#       fastcgi_pass unix:/run/php-fpm/php-fpm.sock;
#       # With php-cgi (or other tcp sockets):
#       fastcgi_pass 127.0.0.1:9000;
#}

e deixámolo o código así:

# pass PHP scripts to FastCGI server
#
location ~ \.php$ {
include fastcgi.conf;
# With php-fpm (or other unix sockets):
fastcgi_pass unix:/run/php-fpm/php-fpm.sock;
#       # With php-cgi (or other tcp sockets):
#       fastcgi_pass 127.0.0.1:9000;
}

Comprobamos a sintaxe do da configuración e recargamos o nginx

nginx -t
nginx -s reload

Copiamos o ficheiro info.php que creamos fai un momento na ruta /srv/http/blog

cp /srv/http/info.php /srv/http/blog/

E comprobamos que funciona o servidor php na url https://d.blog.atio.es

Instalación da versión PHP 7.4

Sen embargo hai aplicacións que non soporta a versión 8 de php e teñen que funcionar nunha versión máis antiga como pode ser a versión 7.4. Vexamos como se instala e como se configura o ficheiro vhost blog:

sudo pacman -S php7-fpm php7-gd php7-pgsql php7-intl php7-xsl php7-imagick php7-apcu php-pspell php7-sodium php7-sqlite
sudo systemctl enable php-fpm7
sudo systemctl start php-fpm7

Podemos comprobar no que no cartafol /run creouse un cartafol php-fpm7 e dentro do mesmo un socket co nome php-fpm.sock

Agora debemos configurar o ficheiro vhost blog, para que poida interpretar os ficheiros php. No caso de non facelo, o servidor Nginx procede a descargalos como se fose un ficheiro pdf. Para isto:

nano /etc/nginx/sites-available/blog

Dirixímonos á sección  php e descomentamos unhas cantas liñas e configuramos correctamente a ruta na que se atopa o php-fp.sock

# pass PHP scripts to FastCGI server
#
#location ~ \.php$ {
#       include fastcgi.conf;
#       # With php-fpm (or other unix sockets):
#       fastcgi_pass unix:/run/php-fpm/php-fpm.sock;
#       # With php-cgi (or other tcp sockets):
#       fastcgi_pass 127.0.0.1:9000;
#}

e deixámolo o código así:

# pass PHP scripts to FastCGI server
#
location ~ \.php$ {
include fastcgi.conf;
# With php-fpm (or other unix sockets):
fastcgi_pass unix:/run/php-fpm7/php-fpm.sock;
#       # With php-cgi (or other tcp sockets):
#       fastcgi_pass 127.0.0.1:9000;
}

E xa unha vez aberto este ficheiro tamén podemos descomentar a parte relativa aos ficheiros .htaccess. O servidor nginx non interpreta este tipo de ficheiros, polo que é unha boa práctica que os ocultemos pois poderían ser descargados como un ficheiro máis. Para isto, cambiamos o seguinte:

#location ~ /\.ht {
#       deny all;
#}

por:

location ~ /\.ht {
deny all;
}

Comprobamos que a sintaxis os ficheiros de configuración de nginx é a correcta e recargamos a configuración

nginx -t
nginx -s reload

E comprobamos que funciona o servidor php coa versión php 7.4 na url https://d.blog.atio.es

E finalmente debemos configurar o php.ini. No caso de empregar a versión php 7.4, editamos o ficheiro:

nano /etc/php7/php.ini

E se queremos configurar as características do php 8.1 editamos:

nano /etc/php/php.ini

Instalamos dúas aplicacións que probablemente precisaremos nalgunha aplicación como Drupal

pacman -Sy  php-gd
pacman -Sy  php-pdo

E activamos a extensión no php.ini correspondente en función da versión de php que vaiamos empregar. Descomentamos as seguintes liñas

;extension=gd
;extension=pdo_mysql
;extension=mysqli

Recargamos o servizo:

systemctl reload php-fpm
systemctl reload php-fpm7

Para a instalación do Drupal é recomendable contar con PHP OPcode caching para acelerar a navegación. Para contar con esta utilidade seguiremos estes pasos:

a. Editamos o ficheiros php.ini, por exemplo se imos traballar coa versión php 7.4 editaremos o seguinte:

nano /etc/php7/php.ini

e faríase de modo idéntico se editamos o php.ini para a versión 8.1 nano /etc/php/php.ini

b. E descomentamos e asignámoslle valores ás seguinte liñas:

zend_extension=opcache
opcache.enable=1
opcache.enable_cli=1
opcache.memory_consumption=128
opcache.interned_strings_buffer=8
opcache.max_accelerated_files=10000
opcache.revalidate_freq=60

Pero ademais para a instalación de Drupal, e para a importación de bases de datos de gran tamaño co phpMyAdmin é conveniente configurar estas liñas:

short_open_tag = On
memory_limit = 512M
cgi.fix_pathinfo = 0
upload_max_filesize = 512M
post_max_size = 512M
max_execution_time = 360
date.timezone = Europe/Madrid

E recargamos o servizo php-fpm7, neste caso

systemctl reload php-fpm7

5. INSTALACIÓN MYSQL

sudo pacman -Syu mariadb mariadb-clients libmariadbclient
sudo mysql_install_db --user=mysql --basedir=/usr --datadir=/var/lib/mysql
sudo systemctl enable mysqld.service
sudo systemctl start mysqld.service

Para comprobar que funciona podemos acceder e crear unha base de datos de proba

mysql
show databases;
EXIT

Configuramos o contrasinal do usuario root:

mysqladmin --user=root password "contrasinal"
sudo mysql -u root -p
CREATE DATABASE drupaldb;
CREATE USER 'drupaldbuser'@'localhost' IDENTIFIED BY 'novo_contrasinal';
GRANT ALL ON drupaldb.* TO 'drupaldbuser'@'localhost' WITH GRANT OPTION;
FLUSH PRIVILEGES;
EXIT;

E para comprobar que funciona a interacción entre php e mysql podemos instalar phpmyadmin

cd /srv/http/blog

wget https://files.phpmyadmin.net/phpMyAdmin/5.1.3/phpMyAdmin-5.1.3-all-languages.zip

unzip phpMyAdmin-5.1.3-all-languages.zip

mv phpMyAdmin-5.1.3-all-languages.zip phpmyadmin

Accedemos desde o navegador, introducindo a seguinte url: http://d.blog.atio.es/phpmyadmin/index.php, e procedemos a crear as base de datos que desexemos.

 

1. Restaurar un curso de WebDinámicas

2. Configuración da avaliación

3. Cálculos con fórmulas

4. Utilidade dalgunha aplicación da maqueta Abalar

A. Comprimir e descomprimir ficheiros.

Crear un cartafol en Documentos

Descargar os seguintes pdf nos que se trata o produto nas matemáticas védicas

https://oaoa.atio.es/sites/oaoa/files/inline-images/vedicas/produto_vedicas_nivel1.pdf

https://oaoa.atio.es/sites/oaoa/files/inline-images/vedicas/produto_vedicas_nivel2.pdf

https://oaoa.atio.es/sites/oaoa/files/inline-images/vedicas/produto_vedicas_nivel3.pdf

https://oaoa.atio.es/sites/oaoa/files/inline-images/vedicas/produto_vedicas_nivel4.pdf

Cortar e pegar desde Descargas a Documentos

Comprimir

B. Gimp

a. Escalar unha imaxe

Descarga a seguinte imaxe: https://atio.es/pub/cancha.jpg

Escalar a imaxe para que non teña un ancho superior a 500px

b. Recortar unha imaxe

Descargar unha imaxe da seguinte web: https://unsplash.com/

Recorta quedando só cunha parte da foto

c. Crear unha imaxe cun tamaño 1100*300px

Ficheiro Novo > tamaño 1100*300px

Descarga a seguinte imaxe: https://atio.es/pub/carnota.jpg

Abrir en nova capa e escalamos a capa

C. Klavaro

D. Handbrake

Descargar o vídeo: http://www.edu.xunta.gal/centros/cracoristancosantacomba/system/files/_VIDEO%2025%20N.mp4

Modificar o tamaño a 720*405px

E. Inkscape

Descarga esta imaxe: https://atio.es/pub/bolboreta_azul.svg

Abrea co Inkscape

Duplicaa varias veces

Exporta

F. Scribus

Abre Lipsum e xera un texto. Copia unha porción

Abre o Scribus e pincha en inserir unha moldura de texto e pega o texto.

Exporta a PDF

G. Comunicación coas familas empregando Abalar Móbil. Un caso práctica empregando Agueiro

4. Crear exame autocorrixible

5. Introdución ás actividades H5P

6. Personalizar os libros da editorial Netex, Edebé e Planeta

7. Avaliación das tarefas dos libros da editorial Netex, Edebé e Planeta

 

Como xa vimos na nova https://blog.atio.es/node/395, os exercicios seriados resultan moi útiles para o alumnado. Ao repetir o mesmo algoritmo varias veces, o alumno afianza a resolución dun modelo de exercicio. Vexamos nesta ocasión como se edita un boletín de exercicios en RStudio.

Paso 1. Instalamos RStudio. Quedou explicado nestas dúas novas:

a. Instalación en Arch Linux: https://blog.atio.es/node/434

b. Instalación en Debian: https://blog.atio.es/node/417

Paso 2. Descargamos un documento mestre editado con RStudio e descomprimímolo. Neste caso xa o deixo exemplificado cuns exercicios de corrente continua, que irei mellorando progresivamente.

https://atio.es/pub/boletin_rstudio.zip

Paso 3. Abrimos: File > Open Project e procuramos o ficheiro boletin_mestre.Rproj

Paso 4. Abrimos Principal e xa prememos en Knit > knit to PDF. Se non xerase ningún documento pdf, debemos de ir instalando os paquetes nos que teñamos un erro.

E xa descifrando un pouco código, observamos que na páxina principal dispoñemos dun chunk, que non é máis que un FOR que chama de maneira reiterativa ao ficheiro link_exercicios.Rmd. Non acadei facelo máis sinxelo.

```{r results='asis', echo=FALSE}
    res <- vector("list", length = 10)
    for (i in 1:10) {
      res[[i]] <- knitr::knit_child("link_exercicios.Rmd", quiet = TRUE, envir = environment())
    }
    cat(unlist(res), sep = '')
```

Neste exemplo, crea 10 boletíns. Pero chega un momento que aínda que subamos a cifra de pdfs non crea máis, e débese a limitacións de memoria. Terei que investigar un pouco máis no asunto.

O ficheiro link_exercicios.Rmd a súa vez chama a todos os ficheiros que dispoñemos no cartafol exercicios:

```{r child = './exercicios/exercicio1.Rmd'}
```
```{r child = './exercicios/exercicio2.Rmd'}
```
```{r child = './exercicios/exercicio3.Rmd'}
```
```{r child = './exercicios/exercicio4.Rmd'}
```
```{r child = './exercicios/exercicio5.Rmd'}
```
```{r child = './exercicios/exercicio6.Rmd'}
```

Se incrementamos o número de exercicios, debemos de facelo tamén neste listado.

E por último, en cada exercicio, observamos dúas partes: na primeira facemos os cálculos con R. Tamén os podemos facer en Python, tal e como expliquei neste post: https://blog.atio.es/node/435 , aínda que non é necesario saír da linguaxe de programación R.

```{r echo=FALSE}
v <- sample (c(10,20,30,40,50), size=1)
r <- sample (c(2,3,4,5), size=1)
i <- round(v/r, 2)
```

Na segunda parte imprimimos no documento o enunciado do problema coas asignación das variables facilitadas polos cálculos da primeira parte:

1. Conéctase unha resistencia de `r r` k$\Omega$ a unha pila de `r v` V. Cal é a intensidade de corrente eléctrica que percorre o circuíto?
\newline
\newline
Solución: I= `r i` mA

Un detalle importante, consiste en rematar o último exercicio do boletín coa instrución \clearpage. A finalidade é a de introducir un salto de páxina e deste xeito, cada boletín comece co exercicio 1.

E o resultado quedaría do seguinte xeito: