Description des scripts à utiliser pour simplifier le mappage de compte d’utilisateur entre un client UNIX et un serveur basé sur Windows

INTRODUCTION

Cet article est pour les fabricants ou les clients qui sont intéressés par l’utilisation de Windows Server 2008 ou Windows Storage Server 2008 comme système de fichiers réseau (NFS) serveur de fichiers pour les clients UNIX dans un environnement où le service Active Directory n’existe pas. Cet article contient des conseils sur la façon de script de configuration de tous les composants nécessaires pour activer le mappage de compte d’utilisateur entre le client UNIX et le serveur basé sur Windows.

Plus d'informations

Les scripts fonctionnent dans le code suivant deux phases.

Phase 1 :

La première phase définit l’instance d’Active Directory Lightweight Directory Services (AD LDS) et configure le NFS est nécessaire pour prendre en charge le service de mappage de l’utilisateur.

Certains fabricants d’ordinateurs OEM que le navire Windows Storage Server 2008 peut-être préconfigurer le service AD LDS dans le cadre de leur processus d’installation en usine.

Les clients qui souhaitent tirer parti des service AD LDS peuvent utiliser les mêmes scripts pour automatiser la configuration requise pour Windows Server 2008.

Phase 2 :

La deuxième phase crée des utilisateurs et groupes locaux pour faire correspondre les objets AD LDS. Cela est généralement effectuée par le client en tant que processus pour exporter et importer des utilisateurs pour les clients UNIX afin d’établir le mappage de compte approprié en fonction du serveur basé sur Windows.

Côté OEM ou un client (Phase1)

Les fabricants OEM ou les clients qui installent le service nécessitent les fichiers suivants.

Le fichier en usine-d’installation-adlds.cmd

Pour créer le fichier en usine-d’installation-adlds.cmd, copiez le texte suivant dans un fichier Bloc-notes, puis enregistrez le fichier texte avec le nom, en usine-d’installation-adlds.cmd.
setlocal enabledelayedexpansionset opt_insecure=0

for %%i in (%*) do (
if %%i equ insecure set opt_insecure=1
)

rem === create set-defaultnamingcontext.ldf
echo dn: CN=NTDS Settings,CN=%COMPUTERNAME%$NFSInstance,CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,DC=X> set-defaultnamingcontext.ldf
echo changetype: modify>> set-defaultnamingcontext.ldf
echo replace: msDS-DefaultNamingContext>> set-defaultnamingcontext.ldf
echo msDS-DefaultNamingContext: CN=nfs,DC=nfs>> set-defaultnamingcontext.ldf
echo ->> set-defaultnamingcontext.ldf

rem === Install the ADAM role
start /w servermanagercmd -i FS-NFS-Services
start /w servermanagercmd -i ADLDS

rem === Create a ADAM instance for use by Services for NFS named NFSInstance
%systemroot%\ADAM\adaminstall.exe /answer:nfs-instance-answer.txt

rem === Set the default naming context
ldifde -i -f set-defaultnamingcontext.ldf -s localhost:389 -c "cn=Configuration,dc=X" #configurationNamingContext

rem === Extend the schema to add the uidNumber/gidNumber attributes to the user
rem === class and the gidNumber attribute to the group class
ldifde -i -f add-uidnumber-gidnumber.ldf -s localhost:389 -c "cn=Configuration,dc=X" #configurationNamingContext

rem === Add Users container object
ldifde -i -f add-users-container.ldf -s localhost:389

rem === Provide read access to the NFS instance
dsacls \\localhost:389\CN=nfs,DC=nfs /G everyone:GR /I:T
if "!opt_insecure!" equ "1" (
dsacls \\localhost:389\CN=nfs,DC=nfs /G "anonymous logon":GR /I:T
ldifde -i -f change-dsheuristics.ldf -s localhost:389 -j . -c "cn=Configuration,dc=X" #configurationNamingContext
)

rem === Configure the Services for NFS mapping source to use ADAM
nfsadmin mapping config adlookup=yes addomain=%COMPUTERNAME%:389

rem === Cleanup generated file
del set-defaultnamingcontext.ldf

Le fichier Ajout-uidnumber-gidnumber.ldf

Pour créer le fichier Ajout-uidnumber-gidnumber.ldf, copiez le texte suivant dans un fichier Bloc-notes, puis enregistrez le fichier texte avec le nom, ajouter-uidnumber-gidnumber.ldf.
dn: CN=User,CN=Schema,CN=Configuration,DC=Xchangetype: ntdsSchemaModify
add: mayContain
mayContain: 1.3.6.1.1.1.1.0
mayContain: 1.3.6.1.1.1.1.1
-

dn: CN=Group,CN=Schema,CN=Configuration,DC=X
changetype: ntdsSchemaModify
add: mayContain
mayContain: 1.3.6.1.1.1.1.1
-

dn:
changetype: ntdsSchemaModify
add: schemaUpdateNow
schemaUpdateNow:
-

Le fichier container.ldf-utilisateurs-ajouter

Pour créer le fichier container.ldf-utilisateurs-ajouter, copiez le texte suivant dans un fichier Bloc-notes, puis enregistrez le fichier texte avec le nom, ajouter-utilisateurs-container.ldf.
dn: CN=Users,CN=nfs,DC=nfschangetype: add
cn: Users
objectClass: container

Le fichier dsheuristics.ldf-modification

Pour créer le fichier dsheuristics.ldf à la modification, copiez le texte suivant dans un fichier Bloc-notes et puis enregistrez le fichier texte portant le nom dsheuristics.ldf à la modification.
dn: CN=Directory Service,CN=Windows NT,CN=Services,CN=Configuration,DC=Xchangetype: modify
replace: dsHeuristics
dsHeuristics: 0000002001001
-

Le fichier nfs-instance-answer.txt

Pour créer le fichier nfs-instance-answer.txt, copiez le texte suivant dans un fichier Bloc-notes, puis enregistrez le fichier texte avec le nom, nfs-instance-answer.txt.
[ADAMInstall]; The following line specifies to install a unique ADAM instance.
InstallType=Unique
; The following line specifies the name to be assigned to the new instance.
InstanceName=NFSInstance
; The following line specifies the communications port to use for LDAP.
LocalLDAPPortToListenOn=389
; The following line specifies an application partition to create
NewApplicationPartitionToCreate="cn=nfs,dc=nfs"
; The following line specifies the directory to use for ADAM data files.
;DataFilesPath=C:\Program Files\Microsoft ADAM\NFSInstance\data
; The following line specifies the directory to use for ADAM log files.
;LogFilesPath=C:\Program Files\Microsoft ADAM\NFSInstance\data
; The following line specifies the .ldf files to import into the ADAM schema.
ImportLDIFFiles="ms-inetorgperson.ldf" "ms-user.ldf" "MS-AdamSchemaW2K8.ldf"

Le script en usine-adlds.cmd-le programme d’installation effectue les opérations suivantes :
  1. Il génère un fichier ldf pour spécifier un contexte de nommage par défaut pour l’instance ADLDS qui est créé ultérieurement.
  2. Il installe les rôles NFS et AD LDS sur le serveur basé sur Windows Storage Server 2008 ou Windows Server 2008.
  3. Il crée une nouvelle instance AD LDS à l’aide du fichier nfs-instance-answer.txt.

    Remarque : Cette instance est nommée NFSInstance, la partition est « cn = nfs, dc = nfs, « l’instance s’exécute sur le port 389 et le schéma est étendu avec les attributs suivants :
    • MS-inetorgperson
    • MS-utilisateur
    • ms-adamschemaw2k8
  4. Le fichier d’ensemble-defaultnamingcontext.ldf qui a été généré à l’étape 1 définit le contexte de l’instance NFSInstance de nommage par défaut.
  5. Le fichier gidnumber.ldf-uidnumber-ajouter étend le schéma. Pour ce faire, il ajoute les attributs uidNumber et gidNumber pour les classes d’utilisateurs et de groupes.
  6. Le fichier container.ldf-utilisateurs-ajouter permet d’ajouter un objet de conteneur est appelé utilisateurs pour contenir les objets utilisateur et groupe qui importera les clients.
  7. Les paramètres de sécurité sur l’instance de NFSInstance sont modifiées afin d’activer les autorisations de lecture pour tout le monde groupe.
  8. Si non sécurisé a été spécifié comme argument de ligne de commande lors de l’exécution du script en usine-d’installation-adlds.cmd, la sécurité sur l’instance de NFSInstance est assouplie supplémentaires pour permettre des accès non locaux à l’instance.

    Remarque En règle générale, vous n’avez pas à ajouter le paramètre non sécurisé dans les scénarios les plus courants.
  9. La source du mappage NFS est définie pour utiliser l’instance de NFSInstance.
Dans la phase 1, procédez comme suit :
  1. Copier le fichier en usine-d’installation-adlds.cmd et des fichiers connexes suivants sur l’ordinateur sur lequel vous exécutez NFS :
    • add-uidnumber-gidnumber.ldf
    • add-users-container.ldf
    • change-dsheuristics.ldf
    • nfs-instance-answer.txt
  2. Exécutez le fichier en usine-d’installation-adlds.cmd.
Après avoir exécuté le fichier en usine-d’installation-adlds.cmd, l’instance de NFSInstance est prêt à ce que les objets utilisateur et groupe importés.

Côté client (phase 2)

Côté client, le script suivant est requis

Le script nfs-adlds-config.js

Pour créer ce fichier, copiez le script suivant dans un fichier Bloc-notes, puis enregistrez le fichier texte avec le nom, nfs-adlds-config.js.
var passwdFilename, groupFilename;var passwdFile, groupFile;
var pStr, gStr;
var pLines, gLines;
var pFields, gFields;
var executeCommands = false;

var fso = new ActiveXObject ("Scripting.FileSystemObject");




args = WScript.Arguments;

namedArgs = WScript.Arguments.Named;


passwdFilename = namedArgs.Item("passwd");
groupFilename = namedArgs.Item("group");
ldifFilename = namedArgs.Item("ldf");
usercmdFilename = namedArgs.Item("usercmd");
logFilename = namedArgs.Item("log");
userPassword = namedArgs.Item("userpassword");


for (i = 0; i < args.length; i++)
{
if (args(i) == "/execute")
executeCommands = true;
}



function Print (x)
{
WScript.Echo (x);
}



function Usage ()
{
Print (WScript.ScriptName + " /passwd:passwdfile /group:groupfile /ldf:out.ldf\n" +
" /usercmd:generateusers.cmd [/execute] [/log:logname]\n" +
"\n" +
"/passwd - location of passwd file\n" +
"/group - location of group file\n" +
"/ldf - output generated ldf file\n" +
"/usercmd - output cmd file to generate local users and groups\n" +
"/userpassword - provide a password to be used for all user accounts created\n" +
"/execute - import user objects to ADAM using the generated files\n" +
"/log - specify a filename to log operations\n" +
"\n" +
"Both /passwd and /group must be specified.\n" +
"At least one of /ldf or /usercmd must be specified.\n" +
"If /userpassword is not specified all local accounts created must have\n" +
"passwords set manually before NFS mapping will succeed.\n");
}


function ValidatePasswdGroup ()
{
var i, j;

for (i = 0; i < pLines.length; i++)
{
pFields = pLines[i].split(":");

if (0 == pFields[0].length)
continue;

for (j = 0; j < gLines.length; j++)
{
gFields = gLines[j].split(":");

if (0 == gFields[0].length)
continue;

if (pFields[0] == gFields[0])
{
Print ("The name " + pFields[0] + " occurs in both passwd and group files\n\n");

return false;
}
}
}

return true;
}


function GenerateLdif (s)
{
var i;

for (i = 0; i < pLines.length; i++)
{
pFields = pLines[i].split(":");

if (0 == pFields[0].length)
continue;

s.Write ("dn: CN=" + pFields[0] + ",CN=Users,CN=nfs,DC=nfs\n");
s.Write ("changetype: add\n");
s.Write ("cn: " + pFields[0] + "\n");
s.Write ("objectClass: user\n");
s.Write ("uidNumber: " + pFields[2] + "\n");
s.Write ("gidNumber: " + pFields[3] + "\n");
s.Write ("sAMAccountName: " + pFields[0] + "\n");
s.Write ("\n");
}

for (i = 0; i < gLines.length; i++)
{
gFields = gLines[i].split(":");

if (0 == gFields[0].length)
continue;

s.Write ("dn: CN=" + gFields[0] + ",CN=Users,CN=nfs,DC=nfs\n");
s.Write ("changetype: add\n");
s.Write ("cn: " + gFields[0] + "\n");
s.Write ("objectClass: group\n");
s.Write ("gidNumber: " + gFields[2] + "\n");
s.Write ("sAMAccountName: " + gFields[0] + "\n");
s.Write ("\n");
}
}


function GenerateUserGroupCmd (s)
{
var i, j;

if (!userPassword || 0 == userPassword.length)
{
Print ("WARNING: No /userpassword option was specified, after local accounts\n" +
"are created, passwords must be set on these accounts manually before\n" +
"they can be used for ADLDS mapping for NFS components.\n");
}


//
// Create local groups based on group file
//
for (i = 0; i < gLines.length; i++)
{
gFields = gLines[i].split(":");

if (0 == gFields[0].length)
continue;

s.Write ("net localgroup " + gFields[0] +
" /add /comment:\"Group for GID:" + gFields[2] + "\"\n");
}
s.Write ("\n");


//
// Create local users from passwd file
//
for (i = 0; i < pLines.length; i++)
{
pFields = pLines[i].split(":");

if (0 == pFields[0].length)
continue;

if (userPassword && 0 != userPassword.length)
{
s.Write ("net user " + pFields[0] + " /add /comment:\"User for UID:" +
pFields[2] + " GID:" + pFields[3] + "\" && net user " + pFields[0] + " " + userPassword + "\n");
}
else
{
s.Write ("net user " + pFields[0] + " /add /comment:\"User for UID:" +
pFields[2] + " GID:" + pFields[3] + "\"\n");
}

//
// Add users to their primary groups
//
for (j = 0; j < gLines.length; j++)
{
gFields = gLines[j].split(":");

if (0 == gFields[0].length)
continue;

if (gFields[2] == pFields[3])
{
s.Write ("net localgroup " + gFields[0] + " " + pFields[0] +
" /add\n");
}
}

s.Write ("\n");
}
s.Write ("\n");


//
// Add users to supplementary groups
//
for (i = 0; i < gLines.length; i++)
{
gFields = gLines[i].split(":");

if (4 == gFields.length && 0 != gFields[3].length)
{
supUsers = gFields[3].split(",");

for (j = 0; j < supUsers.length; j++)
{
s.Write ("net localgroup " + gFields[0] + " " + supUsers[j] + " /add\n");
}
}
}
s.Write ("\n");
}






if (!passwdFilename || !groupFilename ||
(!ldifFilename && !usercmdFilename))
{
Usage ();
}
else
{
passwdFile = fso.OpenTextFile (passwdFilename, 1);
groupFile = fso.OpenTextFile (groupFilename, 1);

pStr = passwdFile.ReadAll ();
gStr = groupFile.ReadAll ();

passwdFile.Close ();
groupFile.Close ();

pLines = pStr.split ("\n");
gLines = gStr.split ("\n");


if (!ValidatePasswdGroup ())
{
Print ("error: passwd and group files must not have names that overlap\n" +
" Please edit the files to create unique names.\n");
}
else
{
if (ldifFilename)
{
ldifS = fso.OpenTextFile (ldifFilename, 2, true);

GenerateLdif (ldifS);

ldifS.Close ();
}


if (usercmdFilename)
{
usercmdS = fso.OpenTextFile (usercmdFilename, 2, true);

GenerateUserGroupCmd (usercmdS);

usercmdS.Close ();
}

if (executeCommands)
{
var oShell = WScript.CreateObject("WScript.Shell");
var command = "cmd /k ";

if (ldifFilename)
{
command = command + "echo Importing user objects & ldifde -i -f " + ldifFilename + " -s localhost:389 ";

if (logFilename)
{
command = command + ">>" + logFilename + " 2>&1 ";
}

command = command + "& echo command complete ";

if (usercmdFilename)
{
command = command + "& ";
}
}

if (usercmdFilename)
{
command = command + "echo Creating local users & " + usercmdFilename + " ";

if (logFilename)
{
command = command + ">>" + logFilename + " 2>&1 ";
}

command = command + "& echo command complete ";
}

oShell.Run (command);
}
}

}

Dans la phase 2, le client exécute le script nfs-adlds-config.js. Ce script remplit l’instance NFSInstance avec des objets utilisateur et groupe qui sont basés sur le fichier passwd et le fichier de groupe. Ensuite, ce script crée des utilisateurs et groupes locaux pour faire correspondre les objets AD LDS.

Avant d’exécuter le script

Copie le script Nfs-adlds-config.js à l’ordinateur qui exécute serveur pour NFS et qui requiert des mappages utilisateur. Copiez le fichier passwd et le groupe contenant les utilisateurs et les groupes à mapper à l’ordinateur qui exécute serveur pour NFS à partir d’un ordinateur UNIX.

Ensuite, modifiez le fichier passwd et un fichier de groupe pour supprimer des utilisateurs ou des groupes que vous ne souhaitez pas mapper. Certains utilisateurs d’UNIX et de groupes ont des noms identiques, telles que : racine de l’utilisateur / groupe : racine. Le script échoue et demander un avertissement si le fichier passwd et le fichier de groupe contient des noms identiques pour les utilisateurs et les groupes. Par conséquent, ces noms doivent être modifiés pour vous assurer que tous les noms sont uniques. Par exemple, vous devez modifier le fichier de groupe et modifier le nom de groupe « racine » à « rootgrp ».

Nfs-adlds-config.js script effectue les opérations suivantes :
  • Le script utilise le fichier passwd et le fichier de groupe comme entrée et génère un fichier ldf qui importe tous les objets utilisateur et groupe dans l’instance de NFSInstance.
  • Le script définit l’attribut uidNumber et l’attribut gidNumber, basé sur le fichier passwd et le fichier de groupe.
  • Le script génère un fichier cmd qui contient des commandes permettant de créer des utilisateurs et groupes locaux, et le script ajoute les utilisateurs à leur groupe principal.
  • Le script exécute également les commandes pour importer des objets utilisateur et groupe, et le script crée les utilisateurs et groupes locaux.

Scénario courant pour les clients

En règle générale, une fois que le script est copié, et les fichiers passwd et group sont modifiés, le client doit exécuter la commande suivante :
Nfs-adlds-config.js /passwd:passwd /group:group /ldf:users.ldf /usercmd:create-local-users-groups.cmd /execute /log:configure-adlds.txt
Si l’argument / execute n’est pas spécifié, le users.ldf et le créer-local-utilisateurs-groups.cmd sont créés. Le client peut exécuter créer-local-utilisateurs-groups.cmd et puis exécutez la commande suivante pour importer des utilisateurs et des groupes dans l’instance de NFSInstance :
LDIFDE-I -f users.ldf -s localhost:389
Après l’exécution du script de clients, les clients doivent définir des mots de passe pour les utilisateurs locaux qui ont été créés, en fonction de la stratégie de mot de passe qu’ils utilisent dans leur environnement, pour les utilisateurs locaux. Ou bien, vous devez spécifier l’argument de /userpassword lorsque vous exécutez le script nfs-adlds-config.js. Cet argument vous permet de générer un mot de passe qui peut être utilisé pour tous les comptes d’utilisateur. Jusqu'à ce qu’un mot de passe est spécifié, les comptes d’utilisateurs ne sont pas actifs, et le composant Server for NFS ne peut pas utiliser ces comptes.
Propriétés

ID d'article : 973840 - Dernière mise à jour : 13 janv. 2017 - Révision : 1

Commentaires