Cygwin : commande d’installation de package apt-cyg

Dans cygwin pour avoir une commande d’installation de package comme apt-get sous debian, on peut installer apt-cyg (https://github.com/transcode-open/apt-cyg)

Pour ce faire on exécute les commandes suivantes :

$ lynx -source rawgit.com/transcode-open/apt-cyg/master/apt-cyg > apt-cyg
$ install apt-cyg /bin

par la suite on peut donc lancer des installation comme ça :

$ apt-cyg install nano

Forcer la synchronisation de la date et de l’heure du système avec le réseau au démarrage sous Windows

Lorsque l’ordinateur a tendance à se désynchroniser avec l’heure du réseau (par exemple lorsque l’on passe de Linux à Windows en dual boot).

Créer un fichier MiseAJourDeLHeure.bat

Coller dans ce fichier les lignes suivantes :

start /W net stop w32time
start /W net start w32time

start /W w32tm /resync

start /W net stop w32time
start /W net start w32time

(remarque le sart lance une commande cmd et le /W indique que l’on attend que l’exécution de la commande se termine avant de passer à la suivante)

On lance Tâches planifiées (Scheduled tasks).

Cliquer sur Créer une tâche.

Taper un nom par exemple MiseAJourDeLHeure.
Cocher Exécuter avec les autorisations maximales.
Dans l’onglet Déclencheurs choisir un événement de déclenchement par exemple Au démarrage du système (si l’ordinateur est connecté dès le démarrage par exemple s’il est connecté en Ethernet) ou sinon Sur événement (choisir de Base, puis choisir le Journal : Microsoft-Windows-NetworkProfile/Opérationnel, puis choisir la Source : NetworkProfile, puis saisir un ID d’événement comme par exemple 10000).
Dans l’onglet Actions indiquer le fichier MiseAJourDeLHeure.bat pour qu’il soit exécuté.
Dans l’onglet Conditions choisir le paramétrage. (tout décocher)
Dans l’onglet Paramètres : cocher uniquement : Autoriser l’exécution de la tâche à la demande, Arrêter la tâche si elle s’exécuter plus de 3 minutes, Si la tâche ne se termine pas au moment demandé, forcer son arrêt.

Désormais au démarrage ou suite à la connexion à un réseau, la date et l’heure sont resynchronisées avec le réseau.

Installer WordPress avec NGINX sur Debian ou Ubuntu en utilisant EasyEngine

$ apt-get update
$ apt-get upgrade

ça peut être utile pour pouvoir faire fromdos :

$ apt-get install tofrodos

1)

$ useradd -m username
$ passwd username
$ passwd root
pour connaître le shell utilisé par l’utilisateur (bash, zsh, sh…)

$ getent passwd root

root:x:UID:UID:root:/root:/bin/bash #on voit ici que bash est le shell utilisé par root ici

pour changer le shell utilisé par l’utilisateur :

$ chsh -s /bin/bash root

par défaut lors de la création le shell est sh :

$ getent passwd username

-> username:x:UID:UID::/home/username:/bin/sh
on va mettre le shell bash plus évolué

$ chsh -s /bin/bash username

2) on rajoute le droit d’utiliser sudo au user

$ usermod -a -G sudo username

3) générer une paire de clefs RSA (clef privée et clef publique) avec PuTTY key generator. (Choisir une clef de type SSH-2 RSA, la taille de la clef par exemple 2048 ou 4096 bits, puis cliquer sur Generate. Puis lorsque c’est fini, faire Save public key et Save private key. Attention la private key doit comme son nom l’indique rester secrète…)

4)

$ su – username

5)

$ mkdir .ssh
$ chmod 700 .ssh
$ nano .ssh/authorized_keys

6) copie de la clef publique dedans
enlevez les commentaires qui ne servent à rien (si présents)
supprimez tous les retours à la ligne inutiles
ajoutez ssh-rsa avant la clé (si vous avez généré une clé RSA bien entendu)
ajoutez user@nom_de_votre_serveur à la fin de la clé
on retrouve le nom du serveur avec à la commande hostname
puis CTRL + x et y (pour yes) ou o (pour oui)

7)

$ chmod 600 .ssh/authorized_keys
$ exit

8)

$ nano /etc/ssh/sshd_config

-> PermitRootLogin no
-> port LeNumeroChoisi par défaut 22 (sinon choisir entre 1024 et 65537) : dans notre cas le laisser à 22 pour pouvoir installer facilement EasyEngine
-> décommenter AuthorizedKeysFile %h/.ssh/authorized_keys
-> PermitEmptyPasswords no
-> PasswordAuthentification no
-> LoginGraceTime 30 (max temps pour se connecter en secondes)
Rajouter les lignes suivantes :
-> ClientAliveInterval 600 (max temps d’inactivité en secondes)
-> ClientAliveCountMax 0 (nombre max de message de le serveur peut envoyer sans recevoir aucune réponse de sa part)

9)

$ systemctl restart ssh

10) Déconnexion et reconnexion avec le compte user

Pour se connecter à notre serveur, il faut désormais paramétrer PuTTY pour qu’il utilise notre clef privée : Dans Category > Connection > SSH > Auth -> Au niveau de Private key file for authentification faire Browse… et sélectionner le fichier  de la clef privée (.ppk)

11)

$ wget -qO ee rt.cx/ee && sudo bash ee

12)  pour définir les paramètres de création du serveur :

$ sudo nano /etc/ee/ee.conf

13)

$ sudo ee site create example.com –php7
$ sudo ee site update example.com –mysql
$ sudo ee site update example.com –wp
$ sudo ee site update example.com –wpfc
$ sudo ee site update example.com –letsencrypt

14)  Forcer l’utilisation de HTTPS et non de HTTP  avec HTTP Strict Transport Security HSTS :

$ sudo nano /etc/nginx/sites-available/nom_du_site

insérer la ligne suivante dans le bloc server pour forcer les connexions en https pendant 100 ans :

add_header Strict-Transport-Security ‘max-age=3153600000; includeSubDomains; preload’;

puis on redémarre NGINX :

$ sudo service nginx restart

15)  Mise en place du Pare-feu – Firewall

Vérifier les règles par défaut du firewall :

$ sudo iptables -L

Si aucune règles de pare-feux n’a été défini alors on obtient :
Chain INPUT (policy ACCEPT)
target     prot opt source               destination

Chain FORWARD (policy ACCEPT)
target     prot opt source               destination

Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination

On crée alors un fichier qui va contenir les règles de pare-feux :

$ sudo nano /etc/iptables.firewall.rules

Y copier : 

*filter

# Allow all loopback (lo0) traffic and drop all traffic to 127/8 that doesn’t use lo0
-A INPUT -i lo -j ACCEPT
-A INPUT -d 127.0.0.0/8 -j REJECT

# Accept all established inbound connections
-A INPUT -m state –state ESTABLISHED,RELATED -j ACCEPT

# Allow all outbound traffic – you can modify this to only allow certain traffic
-A OUTPUT -j ACCEPT

# Allow HTTP and HTTPS connections from anywhere (the normal ports for websites and SSL).
-A INPUT -p tcp –dport 80 -j ACCEPT
-A INPUT -p tcp –dport 443 -j ACCEPT

# Allows SMTP access
-A INPUT -p tcp –dport 25 -j ACCEPT
-A INPUT -p tcp –dport 465 -j ACCEPT
-A INPUT -p tcp –dport 587 -j ACCEPT

# Allows pop and pops connections
# -A INPUT -p tcp –dport 110 -j ACCEPT
# -A INPUT -p tcp –dport 995 -j ACCEPT

# Allows imap and imaps connections
-A INPUT -p tcp –dport 143 -j ACCEPT
-A INPUT -p tcp –dport 993 -j ACCEPT

# Allow SSH connections
# The -dport number should be the same port number you set in sshd_config
-A INPUT -p tcp -m state –state NEW –dport 22 -j ACCEPT

# Allow ping
-A INPUT -p icmp –icmp-type echo-request -j ACCEPT

# Log iptables denied calls
-A INPUT -m limit –limit 5/min -j LOG –log-prefix « iptables denied:  » –log-level 7

# Drop all other inbound – default deny unless explicitly allowed policy
-A INPUT -j DROP
-A FORWARD -j DROP

COMMIT

Il faut bien évidemment modifier les numéros de port s’il n’ont pas la valeur standard (par exemple pour le numéro de port SSH).
On active ensuite les règles de pare-feux avec la commande suivante :

$ sudo iptables-restore < /etc/iptables.firewall.rules

On revérifie alors que les nouvelles règles sont prises en compte avec la commande :

$ sudo iptables -L

Ensuite pour s’assurer que les règles seront prises en compte à chaque fois que le serveur est rallumé :

  • On crée un nouveau script : 
    $ sudo nano /etc/network/if-pre-up.d/firewall
  • On copie et colle les lignes suivantes dedans : 
    #!/bin/sh
    /sbin/iptables-restore < /etc/iptables.firewall.rules
  • On enregistre et on quitte : Control-X et Y (pour yes) ou O (pour Oui) pour enregistrer
  • On donne la permission d’exécution au script :
    $ sudo chmod +x /etc/network/if-pre-up.d/firewall

16) Installation de Fail2Ban
Fail2Ban est une application qui protège contre les attaques par dictionnaire. Quand Fail2Ban détecte des échecs de connexions multiples provenant de la même adresse IP, il crée des règles de pare-feux temporelles qui bloquent les communications provenant de l’adresse IP de l’attaquant. Par défaut Fail2Ban ne surveille que SSH mais il est possible de le paramétrer pour surveiller aussi http et SMTP.
Pour l’installer :

$ sudo apt-get install fail2ban

Une fois installé, Fail2Ban surveille et dès qu’une adresse IP dépasse le nombre maximal de tentative d’authentification, elle est bloquée (couche réseau) et l’évènement est enregistré dans les logs que l’on trouve dans le fichier/var/log/fail2ban.log

Pour voir les prisons :

$ sudo fail2ban-client status

dans notre cas on voit 1 prison pour les connexions ssh :

On peut voir des infos sur cette prison (IP banniées…) avec :

$ sudo fail2ban-client status ssh

Pour paramétrer la configuration par défaut des « prisons » de fail2ban :

$ sudo nano /etc/fail2ban/jail.conf

On peut alors changer le nombre maximum de tentatives de connexion (maxretry) , le temps de bannissement exprimé en secondes (bantime). De plus si l’on souhaite recevoir un mail pour nous avertir quand une adresse IP est bannie, il suffit de paramétrer une adresse mail de destinataire (destemail)…

Enfin pour que la nouvelle configuration soit prise en compte :

$ sudo fail2ban-client reload

Pour vérifier que fail2ban est bien actif on peut taper :

$ ps -ef | grep fail2ban
17) Renouvellement automatique du certificat
$ sudo crontab -e
MAILTO=aaaaaaa@bbbbb.com
0 0 * * 0 /usr/local/bin/ee site update –le=renew –all

pour le paramétrage de la crontab on peut utiliser l’utilitaire suivant : https://crontab.guru/  ou https://crontab-generator.org/

17) Mise en place d’un système de backup

$cd ~
$mkdir backups
$cd backups
$nano backup_site.sh
#!/bin/sh

script="$0"
basename="$(dirname $script)"

cd $basename

mkdir -p files
mkdir -p files/sitebackup
mkdir -p files/dbbackup

THESITE="nom_du_site.com"
THEDB="nom_de_la_base_de_donnees"

THEDBUSER="nom_de_l_utilisateur_de_la_base_de_donnees"
THEDBPW="mot_de_passe_de_la_base_de_donnees_pour_ce_user"
THEDATE=`date +%Y%m%d_%H%M%S`

mysqldump -u $THEDBUSER -p${THEDBPW} $THEDB | gzip > files/dbbackup/dbbackup_${THEDB}_${THEDATE}.bak.gz

tar –absolute-names -czf files/sitebackup/sitebackup_${THESITE}_${THEDATE}.tar /var/www/$THESITE
gzip files/sitebackup/sitebackup_${THESITE}_${THEDATE}.tar

find files/sitebackup/site* -mtime +5 -exec rm {} \;

find files/dbbackup/db* -mtime +5 -exec rm {} \;

$crontab -e
0 4 * * * /home/Utilisateur/backups/backup_site.sh >/dev/null 2>&1

 

18) Transférer les fichiers de backup vers un autre serveur que l’on nommera serveur de backup pour éviter les confusions.

Pour ce faire nous devons générer une paire de clefs ssh pour notre serveur web. Pour cela exécutons la commandes suivantes :

$ ssh-keygen -t rsa -b 8192

Dans la commande précédente nous avons demandé la création d’une paire de clefs rsa et nous avons précisé la longueur de cette clef ici 8192 bits. Lors de l’exécution, on nous demande dans quel fichier enregistrer la clef ; par défaut la clef privée sera enregistrée dans ~/.ssh/id_rsa et c’est ce que l’on veut dans notre cas car c’est pour notre serveur. La clef publique est enregistrée dans ~/.ssh/id_rsa.pub. On nous demande également un passphrase c’est un mot de passe qui sera nécessaire pour utiliser la clef privée. Dans notre cas, nous le laissons vide.

Remarque nous aurions pu utiliser putty pour générer la pair de clef et nous aurions enregistré ces clefs au même endroit que le fait ssh-keygen.

Sur le serveur de backup, nous allons rajouter la clef publique du serveur web, pour que ce dernier puisse se connecter au serveur de backup en ssh. Pour ce faire on se connecte au serveur de backup puis :

$ mkdir .ssh
$ chmod 700 .ssh
$ nano .ssh/authorized_keys

On y colle le contenu du fichier id_rsa.pub du serveur web (tout sauf la partie user@host ; donc juste ssh-rsa laClef) et en bout de ligne après un espace on rajoute : nomDuCompteUtilisateurDuServeurBackup@NomDuServeurDeBackup
on enregistre puis :

$ chmod 600 .ssh/authorized_keys

La connection ssh prévoit un double vérification : vérification du client et vérification du serveur. Cependant il arrive souvent que seul le serveur vérifie la bonne « identité » du client, le client faisant souvent confiance dans bonne identité du serveur avec lequel il discute… Si l’on ne souhaite pas vérifier la bonne identité du serveur alors on peut rajouter les lignes suivantes à backup_site.sh :

scp -B -o StrictHostKeyChecking=no /home/Utilisateur/backups/files/dbbackup/dbbackup_${THEDB}_${THEDATE}.bak.gz user@serveurBackup:cheminCompletVersLeDossierDeDestinationDbbackup

scp -B -o StrictHostKeyChecking=no /home/Utilisateur/backups/files/sitebackup/sitebackup_${THESITE}_${THEDATE}.tar.gz user@serveurBackup:cheminCompletVersLeDossierDeDestinationSitebackup

Si l’on veut que le serveur web (ici le client) vérifie qu’il entre bien en communication avec le serveur de backup authentique alors on doit rajouter la clef public du serveur de backup aux clefs hôtes connus.

————————————-
ssh en comportement hôte : par défaut les clefs utilisées (dsa, ecdsa, ed25519, rsa) se trouvent dans /etc/ssh/ssh_host_ecdsa_key pour la clef privée et son .pub pour clef publique. Si l’on souhaite changer de place les clefs hôte utilisées, il faut modifier la configuration de ssh (dans /etc/ssh/sshd_config)
————————————-
ssh en comportement client : on peut définir la paire de clef utilisée dans ~/.ssh/id_rsa ou id_dsa ou id_ed25519 ou id_ecdsa ainsi que leur .pub respectif.
————————————-
Permettre à un client de se connecter en ssh avec une clef à un serveur hôte : le client doit déjà générer sa paire de clefs ssh avec ssh-keygen puis copier sa clef dans le fichier ~/.ssh/authorized_keys du serveur hôte en ajoutant après la clef en bout de ligne userServeurHote@machineHote
————————————-
Comment rajouter la clef du serveur dans les known_hosts ; on n’écrira pas dans le fichier ~/.ssh/known_hosts manuellement…Alors on fait ainsi :
One démarre une connection ssh avec l’hôte en mode StrictHostKeyChecking : ssh -o trictHostKeyChecking=yes serveurHote@machineHote
Le système cherche donc dans les known_hosts et ne trouve pas le serveur par conséquent il nous demande si on est certain de vouloir rajouter l’hôte dans cette liste. Pour ce faire, on nous donne le fingerprint de la clef du serveur (on nous indique aussi le type d’algo qui est utilisé : dsa, ecdsa, ed25519 ou rsa) pour que l’on puisse vérifier manuellement la bonne authenticité du serveur.
Avant d’accepter de rajouter l’hôte dans la liste des known_hosts nous allons vérifier sur le serveur que celui-ci est donc bien authentique et pour cela sur le serveur hôte on tape :

$ssh_keygen -lf /etc/ssh/ssh_host_ecdsa_key.pub

Bien évidemment on adapte la commande précédente en fonction du type du type d’algo (dsa, ecdsa, ed25519 ou rsa) ; si c’était un fingerprint de clef rsa, alors on teste avec ssh_host_rsa_key.pub
Si les fingerprints concordent alors on communique bien avec notre serveur hôte et on peut le rajouter dans la liste des hôtes connus known_hosts.

Dans ce cas, on peut rajouter les lignes suivantes à backup_site.sh :

scp -B -o StrictHostKeyChecking=yes /home/Utilisateur/backups/files/dbbackup/dbbackup_${THEDB}_${THEDATE}.bak.gz user@serveurBackup:cheminCompletVersLeDossierDeDestinationDbbackup
scp -B -o StrictHostKeyChecking=yes /home/Utilisateur/backups/files/sitebackup/sitebackup_${THESITE}_${THEDATE}.tar.gz user@serveurBackup:cheminCompletVersLeDossierDeDestinationSitebackup

19) Enfin nous allons rajouter la purge des dossiers du serveur de backup à la fin du fichier backup_site.sh :

ssh -o StrictHostKeyChecking=yes UtilisateurServeurBackup@serveurBackup ‘find cheminCompletVersLeDossierDeDestinationDbbackup -mtime +5 -regextype posix-egrep -regex « .*\.(ok|gz)$ » -exec rm -f {} \;’
ssh -o StrictHostKeyChecking=yes UtilisateurServeurBackup@serveurBackup ‘find cheminCompletVersLeDossierDeDestinationSitebackup -mtime +5 -regextype posix-egrep -regex « .*\.(ok|gz)$ » -exec rm -f {} \;’

Remarque si on ne souhaite pas vérifier la bonne identité du serveur il suffit comme avant d’utiliser trictHostKeyChecking=no, mais c’est une faiblesse au niveau sécurité.

20) Amélioration du transfert des fichiers vers le serveur de backup (18 et 19) : solution plus sécurisée avec des tests que les commandes ssh et scp importantes se sont effectuées correctement et checksum sha512 :

#####################
#####################
sha512_dbbackup_original=`sha512sum files/dbbackup/dbbackup_${THEDB}_${THEDATE}.bak.gz | awk ‘{sub(/ .*$/,"")}1’`
sha512_sitebackup_original=`sha512sum files/sitebackup/sitebackup_${THESITE}_${THEDATE}.tar.gz | awk ‘{sub(/ .*$/,"")}1’`
#####################
scp -B -o StrictHostKeyChecking=yes files/dbbackup/dbbackup_${THEDB}_${THEDATE}.bak.gz UtilisateurServeurBackup@serveurBackup:/home/Utilisateur/backup/files/dbbackup
if [ $? -ne 0 ]
then
exit $?
fi
sha512_dbbackup_apres_transfert=`ssh -o StrictHostKeyChecking=yes UtilisateurServeurBackup@serveurBackup sha512sum /home/Utilisateur/backup/files/dbbackup/dbbackup_${THEDB}_${THEDATE}.bak.gz | awk ‘{sub(/ .*$/,"")}1’`
if [ "$sha512_dbbackup_apres_transfert" != "$sha512_dbbackup_original" ]
then
exit 111111
fi
ssh -o StrictHostKeyChecking=yes UtilisateurServeurBackup@serveurBackup touch /home/Utilisateur/backup/files/dbbackup/dbbackup_${THEDB}_${THEDATE}.bak.gz.ok
#####################
scp -B -o StrictHostKeyChecking=yes files/sitebackup/sitebackup_${THESITE}_${THEDATE}.tar.gz UtilisateurServeurBackup@serveurBackup:/home/Utilisateur/backups/files/sitebackup
if [ $? -ne 0 ]
then
exit $?
fi
sha512_sitebackup_transfert=`ssh -o StrictHostKeyChecking=yes UtilisateurServeurBackup@serveurBackup sha512sum /home/Utilisateur/backups/files/sitebackup/sitebackup_${THESITE}_${THEDATE}.tar.gz | awk ‘{sub(/ .*$/,"")}1’`
if [ "$sha512_sitebackup_original" != "$sha512_sitebackup_transfert" ]
then
exit 222222
fi
ssh -o StrictHostKeyChecking=yes UtilisateurServeurBackup@serveurBackup touch /home/Utilisateur/backups/files/sitebackup/sitebackup_${THESITE}_${THEDATE}.tar.gz.ok
#####################
ssh -o StrictHostKeyChecking=yes UtilisateurServeurBackup@serveurBackup ‘find /home/Utilisateur/backup/files/dbbackup -mtime +5 -regextype posix-egrep -regex ".*\.(ok|gz)$" -exec rm -f {} \;’
ssh -o StrictHostKeyChecking=yes UtilisateurServeurBackup@serveurBackup ‘find /home/Utilisateur/backups/files/sitebackup -mtime +5 -regextype posix-egrep -regex ".*\.(ok|gz)$" -exec rm -f {} \;’
#####################
#####################

21) être prévenu par mail une fois par jour lorsque des packages doivent être mis à jour :

$ sudo apt-get install apticron

Configurer le(s) email(s) destinataire(s) :

$ sudo nano /etc/apticron/apticron.conf

On peut mettre une liste d’emails destinataires (séparés par un espace)

EMAIL="mon.email@serveur_mail mon.email2@serveur_mail"

Pour lancer manuellement l’utilitaire :

$ sudo /usr/sbin/apticron

pour info la configuration crontab d’apticron se trouve dans /etc/cron.d/apticron

22) encore un peu de sécurité :
installation de lynis (Security auditing systems)

$ sudo apt-get install lynis

lancer un audit de sécurité sur le serveur :

$ sudo lynis –check-all

Il faut ensuite parcourir les recommandations de sécurité et faire les modifications nous-mêmes si on les estime pertinentes.

Ajouter un raccourci vers un site que l’on choisit en utilisant un navigateur précis

Sur le bureau faire un clic droit

Cliquer sur « Nouveau »

raccourci_personnalise1

Cliquer sur « Raccourci »

raccourci_personnalise2

raccourci_personnalise3

Mettre le chemin vers l’exécutable du navigateur (le mieux est de le mettre entre guillemets pour éviter les problèmes si un nom de dossier contient des espaces par exemple…) puis après un espace le nom du site que l’on souhaite ouvrir lors de l’ouverture ce qui donne par exemple : "C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" https://www.google.fr/

Cliquer sur suivant

raccourci_personnalise4

Choisir un nom pour ce raccourci

Cliquer sur Terminer

raccourci_personnalise5

On a alors un raccourci personnalisé 🙂

raccourci_personnalise6

Sites intéressants

expressions régulières
https://regex101.com/
https://www.debuggex.com/
http://www.rexv.org/
http://txt2re.com/
http://regexr.com/
http://www.regextester.com/
http://www.regexpal.com/
http://www.rubular.com/
http://regex.larsolavtorvik.com/
http://www.nregex.com/
https://extendsclass.com/regex-tester.html (ce site propose des outils en ligne pour les développeurs dont notamment un service d’aide à l’écriture des regex)

commandes linux
http://juliend.github.io/linux-cheatsheet/
https://crontab.guru/
https://chmod-calculator.com/

commandes git
http://rogerdudler.github.io/git-guide/index.html

commandes git flow
http://danielkummer.github.io/git-flow-cheatsheet/index.fr_FR.html

annuaires de logiciels libres
https://framasoft.org/rubrique2.html
https://sill.etalab.gouv.fr
https://comptoir-du-libre.org/fr/softwares
http://enacit.epfl.ch/logiciel-libre/
https://sourceforge.net/
https://awesomeopensource.com/

list of recommended Windows software
https://wiki.installgentoo.com/index.php/List_of_recommended_Windows_software

Débuter en Perl
https://perso.univ-rennes1.fr/francois.dagorn/perl/

Image et photos libre de droits en Creative Commons Zero
https://openclipart.org/
https://www.pexels.com/

rosettacode : pour comparer la syntaxe des différents langages de programmation
https://rosettacode.org

scriptol : histoire, présentation et comparaison des langages de programmation
https://www.scriptol.fr/
https://www.scriptol.fr/programmation/langages-populaires.php

developpez.com : site d’actualité dans le domaine du développement d’application
https://www.developpez.com/

awesome
https://github.com/sindresorhus/awesome

awesome-python
https://github.com/vinta/awesome-python

awesome-dotnet
https://github.com/quozd/awesome-dotnet

awesome-R
https://github.com/qinwf/awesome-R

awesome-go
https://github.com/avelino/awesome-go

awesome-go-storage
https://github.com/gostor/awesome-go-storage

Go
https://www.golang-book.com/books/intro
https://gobyexample.com
https://go.developpez.com/tutoriels/go-par-l-exemple/
https://www.programming-books.io/essential/go/

Free online IIR design tool
http://t-filter.engineerjs.com/

Petite liste de logiciels intéressants


Continuer la lecture de Petite liste de logiciels intéressants

Ingénieur Spécialité Microélectronique et Informatique