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

 

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 }, 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:

Xunto un cartafol comprimido que emprego como mestre para a maquetación de diferentes manuais en markdown/Latex  no software RStudio. Ireino mellorando co paso do tempo. Para comezar a traballar tan só tedes que ir modificando os ficheiros Rmd que están dentro do cartafol capítulos.

http://atio.es/pub/mestre_rstudio.zip

 

 

E para que serve RStudio? pois para maquetar documentos en formato pdf, html, odt ou docx, cunha calidade boi boa. Vexamos un documento maquetado con RStudio: