Xcode à distance : SSH, VNC et VS Code

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

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 depuis un ordinateur portable Windows, un bureau Linux, un Chromebook ou même un iPad avec un client SSH.

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 'platform=iOS Simulator,name=iPhone 16,OS=18.2' \
  clean build

# Build with workspace (CocoaPods/SPM)
xcodebuild -workspace MyApp.xcworkspace \
  -scheme MyApp \
  -destination 'platform=iOS Simulator,name=iPhone 16' \
  build

# Run unit tests
xcodebuild test \
  -workspace MyApp.xcworkspace \
  -scheme MyApp \
  -destination 'platform=iOS Simulator,name=iPhone 16' \
  -resultBundlePath ./TestResults.xcresult

# Archive for distribution
xcodebuild archive \
  -workspace MyApp.xcworkspace \
  -scheme MyApp \
  -configuration Release \
  -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, l'iOS Simulator et Instruments. C'est la meilleure méthode lorsque vous avez besoin de l'expérience GUI complète de Xcode.

Activer le partage d'écran sur macOS

# Enable Screen Sharing via command line
sudo /System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart \
  -activate -configure -access -on \
  -restart -agent -privs -all

# Alternatively, set a VNC password
sudo /System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart \
  -activate -configure -access -on \
  -clientopts -setvnclegacy -vnclegacy yes \
  -clientopts -setvncpw -vncpw "your-vnc-password" \
  -restart -agent -privs -all

# Verify Screen Sharing is running
sudo launchctl list | grep -i screen

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", "platform=iOS Simulator,name=iPhone 16",
                "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 16"
            ],
            "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 : JetBrains Gateway + AppCode

JetBrains Gateway offre une expérience de développement à distance similaire à VS Code Remote, mais avec l'écosystème IDE JetBrains. Bien qu'AppCode ait été abandonné, vous pouvez utiliser JetBrains Fleet ou le Gateway avec d'autres IDE JetBrains.

Configurer JetBrains Gateway

# Step 1: Download JetBrains Gateway from jetbrains.com/remote-development/gateway/

# Step 2: Configure SSH connection
# In Gateway: New Connection > SSH
# Host: your-mac.myremotemac.com
# User: your-username
# Authentication: Key pair (select your private key)

# Step 3: Select IDE Backend
# Choose "IntelliJ IDEA" or "Fleet" to run on the remote Mac
# Gateway downloads and installs the IDE backend on the server

# Step 4: Open your project
# Navigate to your project folder on the remote Mac
# The IDE opens with full language support and indexing

Astuce : JetBrains Gateway 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

# 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
mkdir -p ~/Library/MobileDevice/Provisioning\ Profiles/
cp MyApp_Distribution.mobileprovision \
  ~/Library/MobileDevice/Provisioning\ Profiles/

# List installed profiles
ls ~/Library/MobileDevice/Provisioning\ Profiles/

# Decode profile info
security cms -D -i ~/Library/MobileDevice/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.

# ~/.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.

# Create 8GB RAM disk
diskutil erasevolume HFS+ \
  "RAMDisk" $(hdiutil attach \
  -nomount ram://16777216)

# 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:
sudo displayplacer "id:1 res:1920x1080 hz:60 color_depth:8 scaling:off"

# Install displayplacer if needed
brew tap jakehilborn/jakehilborn
brew install displayplacer

# List current display settings
displayplacer list

Questions fréquentes

Quelle méthode choisir : SSH, VNC ou VS Code ?

La plupart des développeurs utilisent une combinaison. VS Code Remote SSH pour le codage quotidien (meilleure expérience d'édition), SSH pour les builds rapides et les scripts, et VNC quand vous avez besoin d'Interface Builder ou du GUI du Simulateur. Commencez avec VS Code Remote SSH et ajoutez VNC quand nécessaire.

Puis-je utiliser l'aperçu SwiftUI de Xcode à distance ?

Oui, mais uniquement via VNC car les aperçus SwiftUI nécessitent le GUI de Xcode. Connectez-vous via VNC, ouvrez votre projet dans Xcode et utilisez l'aperçu du canvas comme d'habitude. L'aperçu se met à jour en temps réel sur le Mac distant.

Quelle bande passante le VNC utilise-t-il ?

Le VNC utilise généralement 1 à 5 Mbps pour le travail de développement normal en 1920x1080. Le défilement actif ou les animations peuvent atteindre 10 à 15 Mbps. Une connexion de 25 Mbps est confortable pour une utilisation VNC en journée complète. SSH et VS Code Remote utilisent beaucoup moins de bande passante (moins de 1 Mbps).

Puis-je exécuter plusieurs instances Simulator à distance ?

Oui. Le Mac Mini M4 dispose de suffisamment de RAM et de cœurs CPU pour exécuter plusieurs instances Simulator simultanément. C'est utile pour tester différents modèles d'iPhone ou exécuter des tests UI en parallèle. Utilisez 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 ?

Si vous utilisez 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.

Développement Xcode à distance : Guide de configuration complet

Table des matières