https://support.apple.com/fr-fr/HT201255
https://support.apple.com/fr-fr/HT204904

Alt : Boot menu
⇧ : Mode sans échec
Super+S : Mode monoutilisateur (root en CLI)

Super+R : Récupération via partition de récup (OS actuel)
Alt+Super+R : Récupération via internet (OS le plus récent compatible)
⇧+Alt+Super+R : Récupération via internet (OS d’origine, ou le plus proche encore disponible sur les serveurs)

Alt+Super+P+R : reset PRAM
Alt+⇧+Ctrl : reset SMC

D : AHT
Alt+D : AHT via internet

Titre 1

Titre 2

Titre 3

Titre 4

Titre 5

Titre 6

Elément en italique
Élément en italique aussi (étoiles)
Élement en gras

Lien html

Mac OS a tendance à laisser des fichiers un peu partout dans les répertoires auxquels il a accès en écriture.
Pour les supprimer, sous Windows :

cd /d X:\infected\folder
del /s /q /f /a .DS_STORE
del /s /q /f /a:h ._.*
del /s /q /f /a:h ._* # cela peut suprrimer aussi certains fichiers de chrome, attention s'il y'a un profil dans le chemin !
del /s /q /f /a __MACOSX

Le /a permet de matcher quels que soient les attributs.

Sous linux :

find ./ \( -name ".AppleDouble" -o -name .DS_Store -o -name ._.* \) -exec rm -Rf {} \;

Préférences système -> Utilisateurs -> Ouverture

/Library/LaunchAgents et ~/Library/LaunchAgents

/Library/StartupItems

/Library/LaunchDaemons

/var/db/launchd.db/

Pour consulter : launchctl list |more

Il est possible, sous OSX, de spécifier des serveurs DNS différents selon le domaine que l’on cherche à joindre. Ainsi, on peut avoir des domaines professionnels privés toujours accessibles, quel que soit la connexion derrrière laquelle on se trouve.

Il faut pour ceci créer le répertoire /etc/resolver/ , puis créer dedans un fichier du nom du domaine à résoudre, contenant la directive nameserver 1.2.3.4. Par exemple, pour accéder au RPVA des avocats : /etc/resolver/e-barreau.fr contiendra nameserver 192.168.1.2, avec l’adresse vers le boitier RPVA.

Lorsqu’on sauvegarde avec Time Machine sur un disque réseau (fonctionnement différent du disque local), les données sont stockées au format .sparsebundle, une image disque qui s’étend à volonté, et qui contient un plusieurs anciennes versions des fichiers. Bien qu’elle apparaisse en tant que fichier sous OSX, une image qu’on peut monter dans le Finder pour en lire/écrire le contenu, c’est en réalité un dossier, qui contient quelques petits fichiers descriptifs, et surtout un gros dossiers, bands, qui contient lui-même toutes les données de l’image, découpé en fichiers de 8,4 Mo. Seule une petite partie de ces fichiers est mise à jour lors d’une sauvegarde Time Machine, et seule cette petite partie sera synchronisée via Rsync (environ 300 Mo. Il va de soi qu’avoir une connexion avec un bon upload, dans le cas d’une sauvegarde réellement distante, est un gros plus.

L’idée du script qui va suivre est de, régulièrement :

• déclencher une sauvegarde Time Machine
• monter le volume de sauvegarde (volume réseau, appelé “Time Capsule” ici, bien que ce puisse être n’importe quel volume proprement configuré) sur un point de montage précis
• synchroniser le point de montage via rsync, avec un serveur ssh (par définition n’importe où dans le monde)

Les prérequis sont :

• avoir configuré, via GUI ou autre, Time Machine, et être sûr que le setup fonctionne correctement
• avoir configuré la redirection de ports sur le routeur devant le serveur ssh
• avoir une configuré une authentification ssh sur le serveur via clé, sans demande de mot de passe, pour pouvoir l’automatiser
• savoir identifier la time capsule sur le réseau, y accéder via hostname et connaître un couple user/password valide pour la lecture des données
• avoir désactivé la planification de Time Machine. Le script s’occupe de lancer la sauvegarde, et une MAJ du contenu du sparsebundle pendant la synchronisation distante via rsync pourrait créer une incohérence dans les données.
• avoir une système de fichiers de destination (sur le serveur ssh) qui supporte les liens durs (hard-link). Typiquement ext4. Bien qu’on stocke du HFS+, il n’est pas nécessaire que cette destination sot en HFS+, car le .sparsebundle contient un système de fichier virtuel, qui s’occupe de conserver toutes les permissions/ACL/attributs étendus nécessaires.

Voici le script proprement dit, très inspiré de cet article, avec un bon paquet de code copié/collé. Cependant, je choisis de simplement conserver les x dernières versions de la sauvegarde. En effet, Time Machine s’occupe déjà de faire un historique régulier (journalier, mensuel, annuel etc), le but de cette sauvegarde est simplement de la déporter sur un site externe, tout en pouvant retrouver une ancienne version en cas de corruption des données Time Machine, et en conservant la facilté de restauration. Ainsi, avec le paramètre daystokeep=90, nous disposons de 3 mois d’historique du contenu de la Time Capsule.

#!/bin/sh

### VARS
  # local
identifier=`hostname`
# the following folder will store lock and log files
filesPath="/path/to/folder with spaces/"  # must contain the trailing /
logfile="${filesPath}${identifier}.log"
lockfile="${filesPath}${identifier}.lck"


  # TimeCapsule (source)
  # should match the Time Machine settings (via TM GUI)
  # name is the Zeroconf name provided in the "Time Capsule" tab within the Airport Utility, finishing by .local
  # for the actual Time Capsule, username seems to be indifferent, but you need the correct password
  # for any AFP share server, username have to be correct
tc_name="Time-Capsule.local"  # it never contains spaces
tc_share="Server Backups"
tc_user="timemachine"
  # if password contains a @ sign, replace it with %40. Spaces are OK.
tc_pw="password %40 TimeCapsule"
tc_mount_point="/Volumes/TC/"  # must contain the trailing /
  # this var could be retrieved from the hostname, but is not for the moment
tc_file_name="iMac de User.sparsebundle"


  # Remote disk (destination)
ssh_user='backupuser'
ssh_server='storage.mydomain.com'
ssh_port=1111
ssh_connect="${ssh_user}@${ssh_server} -p $ssh_port "
target="/path/to/folder/" # must contain the trailing /

###  END OF VARS



# Date for this backup.
date=`date '+%Y-%m-%d_%Hh%Mm'`
# Process ID for this backup
mypid=${$}

### Log beginning of the backup
echo "\n" >> "${logfile}"
if [ ! -d "$filesPath" ]
  then mkdir "$filesPath"
  echo `date '+%Y/%m/%d %H:%M:%S '` "[${mypid}] -- $filesPath was just created" >> "${logfile}"
fi

echo `date '+%Y/%m/%d %H:%M:%S '` "[${mypid}] -- backup started" >> "${logfile}"




###  Check if process is already running to avoid multiples backups at the same time
###  which could corrupt data
if [ -f "${lockfile}" ]
then
  # Lockfile already exists, check if it belongs to a running process
  read -r lockpid < "${lockfile}" #Read the first line which contains a PID
  if [ -z "`ps -p ${lockpid} | grep ${lockpid}`" ]
  then
	# The process doesn't exist anymore. Should there be an incomple folder, it will be removed at the end of the script.
	echo `date '+%Y/%m/%d %H:%M:%S '` "[${mypid}] Lockfile for ghost process (PID: ${lockpid}) found, continuing backup." >> "${logfile}"
  else
	echo `date '+%Y/%m/%d %H:%M:%S '` "[${mypid}] Lockfile '${lockfile}' for running process (PID: ${lockpid}) found, backup stopped." >> "${logfile}"
	exit 73 # can't create (user) output file
  fi
fi
# The lockfile doesn't exist or belongs to a ghost process, make or update it containing the current PID.
echo `date '+%Y/%m/%d %H:%M:%S '` "[${mypid}] -- Création du fichier lock" >> "${logfile}"
echo ${mypid} > "${lockfile}"


### Launch the Time Machine Backup
# On OSX 10.6, the command `/System/Library/CoreServices/backupd.bundle/Contents/Resources/backupd-helper` is a "BACKUP NOW" command
#On 10.7 and later, Apple introduced the `tmutil` command which would allow to do the same
echo `date '+%Y/%m/%d %H:%M:%S '` "[${mypid}] Time Machine backup launched" >> "${logfile}"
/System/Library/CoreServices/backupd.bundle/Contents/Resources/backupd-helper

## The backupd-helper command quits before the save is really finished
## so we check the existence of the process 'backupd'
while [ `/bin/ps -arxo state,comm | /usr/bin/grep backupd | wc -l` -ne 0 ];
do
	echo `date '+%Y/%m/%d %H:%M:%S '` "[${mypid}] Time Machine backup still working. Waiting 180 seconds" >> "${logfile}"
	sleep 180
done
echo `date '+%Y/%m/%d %H:%M:%S '` "[${mypid}] Time Machine backup succeed !" >> "${logfile}"



### Check if the ssh connection can be made, a ssh keypair without keyphrase must exist.
ssh -q -q -o 'BatchMode=yes' -o 'ConnectTimeout 10' ${ssh_connect} exit &> /dev/null

if [ $? != 0 ]
then
  echo `date '+%Y/%m/%d %H:%M:%S '` "[${mypid}] SSH connection ${ssh_connect} failed." >> "${logfile}"

  # Remove lockfile
  rm -f "${lockfile}"

  exit 69 # service unavailable
fi
echo `date '+%Y/%m/%d %H:%M:%S '` "[${mypid}] SSH connection ${ssh_connect} succeed." >> "${logfile}"


### check if target exists
if ssh ${ssh_connect} "[ ! -d '${target}' ]"
then
  echo `date '+%Y/%m/%d %H:%M:%S '` "[${mypid}] Target '${target}' does not exist, backup stopped." >> "${logfile}"

  # Remove lockfile
  rm -f "${lockfile}"

  exit 66 # cannot open input
fi



### Mount the TC volume on the Filesystem
# if mountpoint doesn't exists, we create it
[ -d "$tc_mount_point" ] || mkdir "$tc_mount_point"

# mount the network disc
/sbin/mount_afp "afp://${tc_user}:${tc_pw}@${tc_name}/${tc_share}" "${tc_mount_point}"

# wait for the network disk to be actually mounted
sleep 30

### Make the actual backup of the backup

# check folder for rsync logs
if [ ! -d "${filesPath}"rsync_logs ]
then
    mkdir "${filesPath}"rsync_logs
fi

  echo `date '+%Y/%m/%d %H:%M:%S '` "[${mypid}] Rsync started." >> "${logfile}"

/usr/local/bin/rsync3 \
	-e "ssh -p $ssh_port" \
	--bwlimit=75 \
	--archive \
	--compress \
	--human-readable \
	--delete \
	"${tc_mount_point}${tc_file_name}" \
	"${ssh_user}@${ssh_server}:'${target}latest'" | tee -a "${filesPath}"rsync_logs/`date '+%Y-%m-%d_%Hh%Mm%S '

  echo `date '+%Y/%m/%d %H:%M:%S '` "[${mypid}] Rsync finished." >> "${logfile}"



### Create "history" folder if it doesn't exists
if ssh ${ssh_connect} "[ ! -d '${target}history/' ]"
then
  ssh ${ssh_connect} "mkdir '${target}history'"
fi


### archive current backup
ssh ${ssh_connect} "cp -al '${target}latest' '${target}history/${date}'"

### Remove backups older than specified days
ssh ${ssh_connect} "$target/historyClean.sh"  # this file have to be created on the backup's destination. It is detailed at the end.

### Unmount the TC Volume
/sbin/umount "${tc_mount_point}"

echo `date '+%Y/%m/%d %H:%M:%S '` "[${mypid}] Remote backup successfully finished ! " >> "${logfile}"
# Remove lockfile, this must always be done at the latest moment possible to avoid conflicting processes.
rm -f "${lockfile}"

Et voilà le script historyCleaning, qui doit être mis directement sur la machine (Unix-like) qui contient les sauvegardes du backup Time Machine (par exemple un NAS Synology).

## VARS
target="/path/to/folder/"  # path to the backup's backup. Must match the one in the main script and contain the trailing slash
tc_file_name="iMac de User.sparsebundle"  # must match the one in the main script
daystokeep=200
## END OF VARS

## We search for backups older than daystokeep ; modification time is only on the hostname.sparsebundle folder, so we search it and then we truncate the path
find "$target"history/*/* -maxdepth 0 -type d -mtime +$daystokeep | sed "s#/$tc_file_name##" > $target/dirsToRemove.txt


## We delete each folder
for j in `cat "$target"dirsToRemove.txt`
do
	# it is advised to check if everything is ok
	echo $j
	# if ok, uncomment this line
	#rm -R $j
done

Réalisé avec un Mac Mini sous Lion (10.7.4) fraichement installé, et un client MacBook Pro sous la même version.

Etapes :

Sur le serveur :

• Installer l’application Server (vendue sur l’app store), et les Server admin Tools v10.7.4 disponibles ici : http://support.apple.com/kb/DL1528 (le français est inclus dans l’installeur)

• créer un annuiare ldap (Open Directory) sur le serveur. Dans l’appli Server, aller dans le menu Gérer -> Gérer les comptes réseau. Ceci déclenche la procédure de création d’annuaire. L’utilisateur diradmin est créé.

• ajouter un utilisateur (usermobile) via l’application Server. Maitenant que le serveur héberge un annuaire, le compte créé sera un utilisateur réseau. On le reconait grâce au petit rond bleu a coté de lui. L’utilisateur est pour l’instant seulement présent dans l’annuaire. il n’a pas encore de répertoire.

Note : Une fois qu’un serveur d’annuaire est créé, un ajoure d’utilisateur via l’application Server créera un compte réseau. Si on veut créer un compte local, il faut passer par les préférences système.

• Dans l’appli Server, ouvrir la partie Partage de Fichiers. Double-cliquer sur Users, et sélectionner “Mettre a disposition des dossiers de départ par AFP”. Eventuellement déselectionner le partage SMB (si environnement homogène mac). Ceci permet la création (et l’accès) à ce dossier pour héberger un dossier home entier. Bien évidemment, penser à activer le partage de fichiers.

• Ouvrir le Gestionnaire de Groupe de travail (Workgroup Manager) disponible dans les Server Admin Tools 10.7. Se connecter à l’annuaire LDAPv3/127.0.0.1 (pas le local). Cliquer sur le cadenas en haut à droite pour déverrouiller avec l’utilisateur diradmin. Sélectionner usermobile, puis aller sur l’onglet “Départ”. Sélectionner /Users et cliquer le symbole – en bas pour supprimer ce dossier Home (sinon, le client obéira betement et créera betement un dossier /Users/usermobile chez lui ! ) Puis séléectionner la ligne afp://server.local/Users et cliquer sur Créer Départ (en bas). Ainsi, le répertoire physique sera créé sur le serveur (/Users/usermobile). Cliquer sur Enregistrer.

• Toujours dans le Workgroup Manager, sélectionner usermobile, et cliquer sur l’icône Préférences (en haut de la fenêtre). Séléctionner “Mobilité”, aller dans l’onglet “Création de compte”, puis “Création”. Cocher Gérer : “Toujours” puis cocher “Créer un compte si l’ouverture…”. Valider par “Appliquer”

————————

On passe maintenant sur le portable (client). Il a bien sûr déjà un compte avec privilèges administrateur, que je nommerai ici admin. L’install est fraîche, c’est donc le seul compte existant (si vous déjà un compte du même nom que usermobile, sauvegardez les données et supprimez-le ! )

• Ouvrir les préférences système puis “Utilisateurs et groupes”. Déverrouiller avec le cadenas en bas à gauche. Cliquer sur Options. A côté de Compte serveur réseau, cliquer sur “Rejoindre”. Rentrer l’IP (ou mieux, le hostname du server, type “mac-mini-de-bidule.local” que l’on peut trouver dans les informations de l’appli Server ) et valider. Accepter les certificats SSL. Continuer sur l’avertissement de non-sécurisation du réseau.

• Toujours dans les Options, devant “Ouverture de session par” sélectionner “nom et mot de passe”.

–> Le portable est maintenant connecté à l’annuaire du serveur. Ainsi, si un utilisateur demande à se connecter et n’existe pas dans les utilisateurs locaux, il ira vérifier si cet utilisateur existe sur le serveur.

• Se déconnecter de la session admin. Rentrer les identifiants et mot de passe de usermobile. Confirmer la création du compte mobile.

–> Il crée le dossier utilisateur en local, et lance la première synchronisation. A partir de la, la synchronisation se fera automatiquement. Vous pouvez définir les options de synchronisation dans Paramètres système –> Utilisateurs et groupes –> sélectionner usermobile –> réglages du compte mobile. Vous avez aussi une icône dans la barre de notification qui indiqué l’état et permet de faire une synchro.

• Maintenant que l’utilisateur existe en local, vous pouvez si vous le souhaitez remettre les utilisateurs à la fenêtre de login.

Sur un serveur OSX Lion Server (mais ceci doit fonctionner avec les versions précédentes), si on essaie un

sudo passwd diradmin

après un mot de passe oublié, il sera impossible de changer le mot de passe car il demande l’ancien. De même logué directement en root (sudo su).

La solution est la suivante : taper en root (su ou sudo) la commande

mkpassdb -dump    #affiche les users et leur slot-ID de la forme 0xf4ac…
mkpassdb -setpassword [Slot-ID]

Il sera alors possible de définir un nouveau mot de passe sans connaître l’ancien.

(Très) inspiré de http://erikslab.com/2008/10/02/os-x-server-reset-diradmins-password/

A partir de Lion, le partage WebDAV est intégré non pas dans la partie “Web”, mais directement dans la partie “Partage de fichiers”. Il fait bien entendu appel à Apache, mais est actif même si la partie “Web” est désactivé (dans ce cas, le serveur Apache continue de fonctionner mais a une configuration particulière qui refuse toute connexion avec un message de page Forbidden)

Pour l’activer sur une install toute fraîche de Lion + Server :

• Aller dans “Partage de fichiers”
• Le dossier pré-partagé présent sous le nom “Dossier public de Prénom NOM” correspond au Dossier personnel (“Départ”) de l’utilisateur. (oui, c’est aberrant, mais c’est ce que je constate)
• Cliquer 2 fois dessus, et cocher la case “Partager avec les périphériques iOS (WebDAV)”.
• Cliquer sur Terminer et attendre que la conf se fasse (quelques secondes).
• Le dossier est maintenant accessible par un client webdav (donc pas un navigateur sauf si extension) à l’URL http://192.168.x.x/webdav/prenom (ajuster votre ip et votre login, bien évidemment) // Selon les clients, ce peut-être avec le protocole dav://login@dossier (par exemple nautilus qui recevra un message Forbidden sur le http:// )

D’une manière générale, on peut aussi rajouter n’importe quel dossier maison. Penser à attendre l’ajout du dossier dans la liste (quelques secondes) et le temps que la conf se fasse. Le dossier “Folder” partagé avec les périphériques iOS (Webdav) sera accessible à l’URL http://192.168.x.x/webdav/Folder

ATTENTION : les dossiers peuvent être sensibles à la casse (avec nautilus ils le sont. dav://prenom@10.0.0.6/webdav/PRENOM ne fonctionnera pas alors que dav://prenom@10.0.0.6/webdav/prenom oui. De même, si le dossier partagé est MAJ, alors dav://prenom@10.0.0.6/webdav/MAJ fonctionnera, contrairement à dav://prenom@10.0.0.6/webdav/maj )