Pourquoi développer à distance ?
Le développement Xcode à distance n'est pas seulement pour les personnes qui ne possèdent pas de Mac. De nombreuses équipes professionnelles utilisent des serveurs Mac distants même lorsqu'elles disposent de machines locales, en raison des avantages significatifs :
-
Serveur de build toujours actif
Votre Mac distant fonctionne 24h/24 dans un datacenter. Les pipelines CI/CD, les builds nocturnes et les tests automatisés s'exécutent sans avoir à laisser votre ordinateur portable ouvert.
-
Réseau 1 Gbps, trafic illimité
Un réseau de qualité datacenter signifie des git clones plus rapides, des téléchargements de dépendances et des uploads d'artefacts accélérés. Les installations CocoaPods et les résolutions SPM se font en quelques secondes.
-
Environnement cohérent
Chaque membre de l'équipe se connecte à la même configuration serveur. Plus de problèmes "ça marche sur ma machine" causés par des versions différentes de macOS ou des configurations Xcode.
-
Travaillez depuis n'importe quel appareil
Accédez à votre environnement de développement Xcode complet sur un serveur macOS dédié depuis un ordinateur portable Windows, un bureau Linux, un Chromebook ou même un iPad avec un client SSH. Besoin de Xcode pour un seul build ? Louez un Mac mini à la journée dès $14/jour (USD, HT) ; désactivez le renouvellement automatique au déploiement et le Mac s'arrête au bout de 24 heures.
Méthode 1 : SSH + xcodebuild CLI
L'approche la plus légère. Vous éditez le code dans votre éditeur préféré en local (ou sur le serveur), puis compilez avec xcodebuild via SSH. Cette méthode fonctionne depuis n'importe quel appareil disposant d'un terminal.
Configurer les clés SSH
# Generate SSH key on your local machine (if you don't have one)
ssh-keygen -t ed25519 -C "dev@company.com"
# Copy your public key to the remote Mac
ssh-copy-id user@your-mac.myremotemac.com
# Configure SSH for convenience (~/.ssh/config)
Host mac-dev
HostName your-mac.myremotemac.com
User your-username
IdentityFile ~/.ssh/id_ed25519
ForwardAgent yes
ServerAliveInterval 60
ServerAliveCountMax 3
Compression yes
# Now connect with just:
ssh mac-dev
Commandes xcodebuild courantes
# List available schemes
xcodebuild -list -project MyApp.xcodeproj
# Build for iOS Simulator
xcodebuild -project MyApp.xcodeproj \
-scheme MyApp \
-destination 'generic/platform=iOS Simulator' \
clean build
# Build with workspace (CocoaPods/SPM)
xcodebuild -workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'generic/platform=iOS Simulator' \
build
# Run unit tests (use any device listed by: xcrun simctl list devices available)
xcodebuild test \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 17,OS=latest' \
-resultBundlePath ./TestResults.xcresult
# Archive for distribution (App Store Connect requires Xcode 26 or later)
xcodebuild archive \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-configuration Release \
-destination 'generic/platform=iOS' \
-archivePath ./build/MyApp.xcarchive \
CODE_SIGN_IDENTITY="Apple Distribution" \
PROVISIONING_PROFILE_SPECIFIER="MyApp Distribution"
# Export IPA from archive
xcodebuild -exportArchive \
-archivePath ./build/MyApp.xcarchive \
-exportPath ./build/ipa \
-exportOptionsPlist ExportOptions.plist
# Upload to App Store Connect
xcrun altool --upload-app \
-f ./build/ipa/MyApp.ipa \
-t ios \
-u "apple-id@example.com" \
-p "@keychain:AC_PASSWORD"
Utiliser tmux pour les sessions persistantes
Utilisez tmux pour maintenir vos builds en cours d'exécution même si votre connexion SSH est interrompue.
# Install tmux via Homebrew
brew install tmux
# Start a new tmux session
tmux new -s build
# Run your build inside tmux
xcodebuild -workspace MyApp.xcworkspace -scheme MyApp build
# Detach from tmux: press Ctrl+B, then D
# Your build keeps running on the server
# Reconnect later
ssh mac-dev
tmux attach -t build
Méthode 2 : VNC pour le GUI complet
VNC vous donne un accès complet au bureau macOS, y compris l'interface visuelle de Xcode, Interface Builder, les simulateurs iOS dans Device Hub et Instruments. C'est la meilleure méthode lorsque vous avez besoin de l'expérience GUI complète de Xcode.
Se connecter au partage d'écran
# My Remote Mac serves Screen Sharing (VNC) on port 59010:
# point your VNC client at YOUR-IP:59010 and sign in with
# your macOS username and password
# On a Mac you manage yourself, turn on Screen Sharing in
# System Settings > General > Sharing. Since macOS 12.1 the
# kickstart command can no longer enable it.
# Verify Screen Sharing is running (over SSH)
sudo launchctl list | grep -i screensharing
Clients VNC recommandés par OS
| Votre OS | Client recommandé | Notes |
|---|---|---|
| Windows | RealVNC Viewer (gratuit) | Meilleures performances, supporte le high-DPI d'Apple |
| Linux | Remmina ou TigerVNC | Remmina intègre le tunneling SSH |
| macOS | Partage d'écran intégré | Ouvrir Finder > Aller > Se connecter au serveur > vnc:// |
| Chromebook | VNC Viewer (Chrome Web Store) | Fonctionne bien pour l'accès GUI basique |
| iPad/iPhone | Screens 5 ou RealVNC | Gestes tactiles pour l'interaction macOS |
Sécuriser VNC via un tunnel SSH
Utilisez toujours un tunnel SSH pour les connexions VNC afin de chiffrer tout le trafic.
# Create SSH tunnel for VNC (run on your LOCAL machine)
ssh -L 5900:localhost:5900 -N -f mac-dev
# Now connect your VNC client to: localhost:5900
# All traffic is encrypted through the SSH tunnel
# On Windows with PuTTY:
# Connection > SSH > Tunnels
# Source port: 5900
# Destination: localhost:5900
# Click "Add", then connect
Conseils d'optimisation VNC
- Résolution d'écran réduite : Réglez le Mac distant sur 1920x1080 au lieu du Retina pour un rendu plus rapide.
- Réduire la profondeur de couleur : Dans votre client VNC, réglez la qualité des couleurs sur Moyenne ou 16 bits pour de meilleures performances.
- Désactiver la transparence : Sur le Mac distant, allez dans Réglages système > Accessibilité > Affichage > Réduire la transparence.
- Fermer les applications inutiles : Chaque fenêtre ouverte augmente les données d'écran à transférer.
- Utiliser la compression SSH : Ajoutez
Compression yesà votre configuration SSH pour le tunnel.
Méthode 3 : VS Code Remote SSH
VS Code Remote SSH vous offre le meilleur des deux mondes : la réactivité d'un éditeur local avec la puissance de calcul du Mac distant. Vos frappes sont locales, vos builds s'exécutent sur le serveur.
Installation et configuration
# Step 1: Install VS Code extensions
# Open VS Code and install these extensions:
# - Remote - SSH (ms-vscode-remote.remote-ssh)
# - Swift (sswg.swift-lang)
# - CodeLLDB (vadimcn.vscode-lldb) - for debugging
# Step 2: Configure SSH in ~/.ssh/config
Host mac-dev
HostName your-mac.myremotemac.com
User your-username
IdentityFile ~/.ssh/id_ed25519
ForwardAgent yes
ServerAliveInterval 60
# Step 3: Connect
# Press Ctrl+Shift+P (or Cmd+Shift+P on macOS)
# Type: "Remote-SSH: Connect to Host"
# Select: mac-dev
# VS Code installs its server component on the remote Mac
# Open your project folder
Configurer les tâches de build
Créez un fichier .vscode/tasks.json dans votre projet pour exécuter xcodebuild depuis VS Code :
{
"version": "2.0.0",
"tasks": [
{
"label": "Build iOS (Simulator)",
"type": "shell",
"command": "xcodebuild",
"args": [
"-workspace", "MyApp.xcworkspace",
"-scheme", "MyApp",
"-destination", "generic/platform=iOS Simulator",
"build"
],
"group": {
"kind": "build",
"isDefault": true
},
"problemMatcher": ["$xcodebuild"]
},
{
"label": "Run Tests",
"type": "shell",
"command": "xcodebuild",
"args": [
"test",
"-workspace", "MyApp.xcworkspace",
"-scheme", "MyApp",
"-destination", "platform=iOS Simulator,name=iPhone 17,OS=latest"
],
"group": "test",
"problemMatcher": ["$xcodebuild"]
},
{
"label": "Clean Build",
"type": "shell",
"command": "xcodebuild",
"args": [
"-workspace", "MyApp.xcworkspace",
"-scheme", "MyApp",
"clean"
],
"problemMatcher": []
}
]
}
Maintenant, vous pouvez appuyer sur Ctrl+Shift+B (ou Cmd+Shift+B) pour lancer un build, et la sortie apparaît dans le terminal intégré de VS Code.
Support du langage Swift dans VS Code
# On the remote Mac, install SourceKit-LSP (comes with Xcode)
# Verify it's available:
xcrun sourcekit-lsp --help
# VS Code Swift extension will automatically detect SourceKit-LSP
# You get:
# - Code completion for Swift and SwiftUI
# - Jump to definition
# - Find references
# - Inline error diagnostics
# - Symbol search
Méthode 4 : IDE JetBrains via SSH (Toolbox App)
JetBrains ne propose plus d'IDE pour les projets Swift et Xcode : AppCode est abandonné (mises à jour et support arrêtés le 31 décembre 2023) et Fleet n'est plus distribué (depuis le 22 décembre 2025). Pour Swift, utilisez Xcode via VNC ou VS Code Remote SSH. Le développement à distance JetBrains reste utile si votre dépôt contient aussi du code Kotlin Multiplatform, backend ou web : la JetBrains Toolbox App se connecte à un Mac en SSH et y exécute le backend d'un IDE basé sur IntelliJ, tandis qu'un client léger affiche l'interface en local (JetBrains Gateway ne fonctionne qu'avec des backends Linux).
Connecter un IDE JetBrains avec la Toolbox App
# JetBrains Gateway only connects to Linux backends: a Mac host
# goes through the JetBrains Toolbox App instead
# Step 1: Install the Toolbox App on your local machine
# (jetbrains.com/toolbox-app)
# Step 2: Create the SSH connection
# In the Toolbox App: SSH > New SSH Connection
# Server: your-username@your-mac.myremotemac.com
# (the Toolbox App uses OpenSSH, so your ~/.ssh/config keys apply)
# Step 3: Install the IDE backend on the remote Mac
# Open the server's Tools tab and pick an IntelliJ-based IDE
# (for example IntelliJ IDEA for Kotlin Multiplatform)
# Step 4: Open your project folder on the remote Mac
# Keep editing Swift in Xcode (Method 2) or VS Code (Method 3)
Astuce : Le développement à distance JetBrains fonctionne mieux avec une connexion internet stable (au moins 10 Mbps). Le client léger effectue le rendu de l'interface localement, donc l'expérience reste réactive même sur de longues distances.
Gestion du code signing à distance
Le code signing est l'une des parties les plus délicates du développement iOS à distance. Voici comment gérer les certificats et les profils de provisionnement sur votre serveur Mac distant.
Exporter les certificats depuis le portail Apple Developer
# Option 1: Export from existing Mac as .p12
# On your local Mac (if you have one):
# Open Keychain Access > My Certificates
# Right-click your distribution certificate > Export
# Save as .p12 with a strong password
# Transfer to remote Mac
scp ~/Desktop/Certificates.p12 mac-dev:~/
# On the remote Mac, import:
security import ~/Certificates.p12 \
-k ~/Library/Keychains/login.keychain-db \
-P "your-p12-password" \
-T /usr/bin/codesign -T /usr/bin/security
# Allow codesign access without password prompts
security set-key-partition-list \
-S apple-tool:,apple:,codesign: \
-s -k "your-login-password" \
~/Library/Keychains/login.keychain-db
# Option 2: Create new certificate on remote Mac
# Use VNC to open Xcode > Settings > Accounts
# Add your Apple ID
# Xcode manages certificates automatically
Gestion du trousseau pour le CI/CD
# Create a dedicated keychain for CI/CD
security create-keychain -p "keychain-password" build.keychain-db
# Set it as the default keychain
security default-keychain -s build.keychain-db
# Unlock the keychain (needed for automated builds)
security unlock-keychain -p "keychain-password" build.keychain-db
# Set keychain timeout to prevent auto-lock during builds
security set-keychain-settings -t 3600 -u build.keychain-db
# Import certificate
security import Certificates.p12 \
-k build.keychain-db \
-P "p12-password" \
-T /usr/bin/codesign
# Let codesign use the key without a prompt (needed over SSH)
security set-key-partition-list \
-S apple-tool:,apple:,codesign: \
-s -k "keychain-password" build.keychain-db
# Add to search list
security list-keychains -s build.keychain-db login.keychain-db
# Verify
security find-identity -v -p codesigning build.keychain-db
Profils de provisionnement
# Download profiles from Apple Developer Portal
# Or use the xcodebuild automatic provisioning:
# Install provisioning profiles manually
# (Xcode 16 and later read them from this folder; older versions
# used ~/Library/MobileDevice/Provisioning Profiles)
mkdir -p ~/Library/Developer/Xcode/UserData/Provisioning\ Profiles/
cp MyApp_Distribution.mobileprovision \
~/Library/Developer/Xcode/UserData/Provisioning\ Profiles/
# List installed profiles
ls ~/Library/Developer/Xcode/UserData/Provisioning\ Profiles/
# Decode profile info
security cms -D -i ~/Library/Developer/Xcode/UserData/Provisioning\ Profiles/MyApp_Distribution.mobileprovision
Stratégies de synchronisation de fichiers
Choisissez la bonne stratégie de synchronisation de fichiers en fonction de votre workflow.
Git (recommandé)
L'approche la plus simple et la plus fiable. Éditez en local, poussez vers un dépôt, tirez sur le Mac distant.
# Local machine: push changes
git add . && git commit -m "Update views" && git push
# Remote Mac: pull and build
ssh mac-dev "cd ~/MyApp && git pull && xcodebuild build"
rsync (synchronisation rapide)
Synchronise uniquement les fichiers modifiés via SSH. Plus rapide que la copie de répertoires entiers.
# Sync local project to remote Mac
rsync -avz --exclude '.git' --exclude 'DerivedData' \
--exclude 'build' --exclude '.DS_Store' \
./MyApp/ mac-dev:~/MyApp/
# Watch for changes and auto-sync (using fswatch on macOS/Linux)
fswatch -o ./MyApp/Sources/ | while read; do
rsync -avz ./MyApp/Sources/ mac-dev:~/MyApp/Sources/
done
SSHFS (monter le système de fichiers distant)
Montez le système de fichiers du Mac distant comme un disque local. Éditez les fichiers comme s'ils étaient en local.
# Install SSHFS
# Linux: sudo apt install sshfs
# macOS: brew install macfuse sshfs
# Windows: Install WinFsp + SSHFS-Win
# Mount remote directory
mkdir ~/remote-mac
sshfs mac-dev:/Users/your-username/MyApp ~/remote-mac
# Edit files locally -- they are actually on the remote Mac
code ~/remote-mac
# Unmount when done
fusermount -u ~/remote-mac # Linux
umount ~/remote-mac # macOS
Conseils de performance
Optimisez votre expérience de développement à distance avec ces réglages.
Compression SSH
Activez la compression dans votre configuration SSH pour réduire le transfert de données.
# ~/.ssh/config
Host mac-dev
Compression yes
CompressionLevel 6
Multiplexage SSH
Réutilisez les connexions SSH pour éliminer les délais de reconnexion.
# Create the socket folder once: mkdir -p ~/.ssh/sockets
# ~/.ssh/config
Host mac-dev
ControlMaster auto
ControlPath ~/.ssh/sockets/%r@%h-%p
ControlPersist 600
DerivedData sur disque RAM
Déplacez le DerivedData de Xcode sur un disque RAM pour des builds plus rapides. Gardez-le petit et réservez-le aux Mac de 24 Go ou plus : le disque est effacé à chaque redémarrage.
# Create a 4 GB RAM disk (24 GB+ Macs only;
# it is erased at every restart)
diskutil erasevolume HFS+ \
"RAMDisk" $(hdiutil attach \
-nomount ram://8388608)
# Point Xcode DerivedData to RAM disk
defaults write com.apple.dt.Xcode \
IDECustomDerivedDataLocation \
/Volumes/RAMDisk/DerivedData
Cache local avec Mosh
Utilisez Mosh au lieu de SSH pour une meilleure réactivité sur les connexions instables.
# Install Mosh on both machines
brew install mosh
# Connect (handles roaming and sleep)
mosh user@your-mac.myremotemac.com
Réglages de résolution VNC
# Set a lower resolution for better VNC performance
# On the remote Mac, install displayplacer (Homebrew core)
brew install displayplacer
# List current display settings (note the display id)
displayplacer list
# Apply 1920x1080, using the id shown by the list command
displayplacer "id:1 res:1920x1080 hz:60 color_depth:8 scaling:off"
Questions fréquentes
Quelle méthode choisir : SSH, VNC ou VS Code ?
Puis-je utiliser l'aperçu SwiftUI de Xcode à distance ?
Quelle bande passante le VNC utilise-t-il ?
Puis-je exécuter plusieurs instances Simulator à distance ?
xcrun simctl pour gérer les instances Simulator en ligne de commande.Que se passe-t-il si ma connexion SSH est interrompue pendant un build ?
tmux ou screen, le build continue de s'exécuter sur le serveur et vous pouvez vous reconnecter à la session. Sans tmux, le processus de build sera arrêté. Nous recommandons vivement de toujours exécuter les builds à l'intérieur d'une session tmux.