Een aangepast type voor vertrouwelijke gegevens maken met PowerShellCreate a custom sensitive information type using PowerShell

In dit onderwerp leert u hoe u PowerShell kunt gebruiken om een XML-regelpakket bestand te maken waarin uw eigen aangepaste typen voor vertrouwelijke gegevens worden omschreven.This topic shows you how to use PowerShell to create an XML rule package file that defines your own custom sensitive information types. U moet weten hoe u een normale expressie maakt.You need to know how to create a regular expression. Dit onderwerp maakt als voorbeeld een aangepast type voor vertrouwelijke gegevens dat een medewerkers-ID identificeert.As an example, this topic creates a custom sensitive information type that identifies an employee ID. U kunt dit voorbeeld-XML-bestand gebruiken als beginpunt voor uw eigen XML-bestand.You can use this example XML as a starting point for your own XML file. Zie Meer informatie over typen voor vertrouwelijke gegevens als typen voor vertrouwelijke gegevens nieuw voor u zijn.If you are new to sensitive information types, see Learn about sensitive information types.

Nadat u een goed opgebouwd XML-bestand hebt gemaakt, kunt u het uploaden naar Microsoft 365 via Microsoft 365 PowerShell.After you've created a well-formed XML file, you can upload it to Microsoft 365 by using Microsoft 365 PowerShell. Vervolgens bent u er klaar voor om uw aangepaste type voor vertrouwelijke gegevens in uw beleid te gebruiken en te testen of de vertrouwelijke gegevens worden gedetecteerd zoal u wilt.Then you're ready to use your custom sensitive information type in your policies and test that it's detecting the sensitive information as you intended.

Notitie

Als u geen behoefte hebt aan de fijngevoelige controle die PowerShell biedt, kunt u aangepaste typen voor vertrouwelijke gegevens maken in het compliancecentrum.If you don't need the fine grained control that PowerShell provides, you can create custom sensitive information types in the Compliance center. Zie Een aangepast type voor vertrouwelijke gegevens maken voor meer informatie.For more information, see Create a custom sensitive information type.

Belangrijke vrijwaringImportant disclaimer

Vanwege de verschillende klantomgevingen en vereisten voor inhoud kan Microsoft-ondersteuning niet helpen door definities te bieden voor aangepaste inhoudsovereenkomsten, zoals bijvoorbeeld aangepaste classificaties of normale expressiepatronen (ook wel RegEx genoemd) definiëren.Due to the variances in customer environments and content match requirements, Microsoft Support cannot assist in providing custom content-matching definitions; e.g., defining custom classifications or regular expression (also known as RegEx) patterns. Voor de ontwikkeling, het testen en de foutopsporing van inhoudsovereenkomsten moeten Microsoft 365-klanten vertrouwen op interne IT-bronnen of een externe bron gebruiken, zoals MCS (Microsoft Consulting Services).For custom content-matching development, testing, and debugging, Microsoft 365 customers will need to rely upon internal IT resources, or use an external consulting resource such as Microsoft Consulting Services (MCS). Ondersteuningstechnici kunnen beperkte ondersteuning bieden voor de functie, maar niet garanderen dat de ontwikkeling van aangepaste inhoudsovereenkomsten voldoet aan de vereisten of verplichtingen van de klant.Support engineers can provide limited support for the feature, but cannot provide assurances that any custom content-matching development will fulfill the customer's requirements or obligations. Als voorbeeld van het soort ondersteuning dat kan worden geboden, kunnen voor testdoeleinden voorbeelden van normale expressiepatronen worden aangeboden.As an example of the type of support that can be provided, sample regular expression patterns may be provided for testing purposes. Of de ondersteuning kan helpen bij het oplossen van problemen met een bestaand RegEx-patroon dat niet zoals verwacht wordt geactiveerd met een enkel voorbeeld met specifieke inhoud.Or, support can assist with troubleshooting an existing RegEx pattern which is not triggering as expected with a single specific content example.

Zie Mogelijke validatieproblemen om rekening mee te houden in dit onderwerp.See Potential validation issues to be aware of in this topic.

Zie Boost.Regex 5.1.3 voor meer informatie over de engine Boost.RegEx (voorheen bekend als RegEx++) die wordt gebruikt voor het verwerken van tekst.For more information about the Boost.RegEx (formerly known as RegEx++) engine that's used for processing the text, see Boost.Regex 5.1.3.

Voorbeeld-XML van een regelpakketSample XML of a rule package

Dit is de voorbeeld-XML van het regelpakket dat we in dit onderwerp gaan maken.Here's the sample XML of the rule package that we'll create in this topic. In onderstaande gedeelten worden elementen en kenmerken uitgelegd.Elements and attributes are explained in the sections below.

<?xml version="1.0" encoding="UTF-16"?>
<RulePackage xmlns="http://schemas.microsoft.com/office/2011/mce">
<RulePack id="DAD86A92-AB18-43BB-AB35-96F7C594ADAA">
    <Version build="0" major="1" minor="0" revision="0"/>
    <Publisher id="619DD8C3-7B80-4998-A312-4DF0402BAC04"/>
    <Details defaultLangCode="en-us">
        <LocalizedDetails langcode="en-us">
            <PublisherName>Contoso</PublisherName>
            <Name>Employee ID Custom Rule Pack</Name>
            <Description>
            This rule package contains the custom Employee ID entity.
            </Description>
        </LocalizedDetails>
    </Details>
</RulePack>
<Rules>
<!-- Employee ID -->
    <Entity id="E1CC861E-3FE9-4A58-82DF-4BD259EAB378" patternsProximity="300" recommendedConfidence="75">
        <Pattern confidenceLevel="65">
            <IdMatch idRef="Regex_employee_id"/>
        </Pattern>
        <Pattern confidenceLevel="75">
            <IdMatch idRef="Regex_employee_id"/>
            <Match idRef="Func_us_date"/>
        </Pattern>
        <Pattern confidenceLevel="85">
            <IdMatch idRef="Regex_employee_id"/>
            <Match idRef="Func_us_date"/>
            <Any minMatches="1">
                <Match idRef="Keyword_badge" minCount="2"/>
                <Match idRef="Keyword_employee"/>
            </Any>
            <Any minMatches="0" maxMatches="0">
                <Match idRef="Keyword_false_positives_local"/>
                <Match idRef="Keyword_false_positives_intl"/>
            </Any>
        </Pattern>
    </Entity>
    <Regex id="Regex_employee_id">(\s)(\d{9})(\s)</Regex>
    <Keyword id="Keyword_employee">
        <Group matchStyle="word">
            <Term>Identification</Term>
            <Term>Contoso Employee</Term>
        </Group>
    </Keyword>
    <Keyword id="Keyword_badge">
        <Group matchStyle="string">
            <Term>card</Term>
            <Term>badge</Term>
            <Term caseSensitive="true">ID</Term>
        </Group>
    </Keyword>
    <Keyword id="Keyword_false_positives_local">
        <Group matchStyle="word">
            <Term>credit card</Term>
            <Term>national ID</Term>
        </Group>
    </Keyword>
    <Keyword id="Keyword_false_positives_intl">
        <Group matchStyle="word">
            <Term>identity card</Term>
            <Term>national ID</Term>
            <Term>EU debit card</Term>
        </Group>
    </Keyword>
    <LocalizedStrings>
        <Resource idRef="E1CC861E-3FE9-4A58-82DF-4BD259EAB378">
            <Name default="true" langcode="en-us">Employee ID</Name>
            <Description default="true" langcode="en-us">
            A custom classification for detecting Employee IDs.
            </Description>
            <Description default="false" langcode="de-de">
            Description for German locale.
            </Description>
        </Resource>
    </LocalizedStrings>
</Rules>
</RulePackage>

Wat zijn uw belangrijkste vereisten?What are your key requirements? [Regel, Entiteit, Patroonelementen][Rule, Entity, Pattern elements]

Voordat u begint is het handig om de basisstructuur van het XML-schema voor een regel te begrijpen en hoe u deze structuur kunt gebruiken om uw aangepaste type voor vertrouwelijke gegevens te definiëren, zodat u de juiste inhoud identificeert.Before you get started, it's helpful to understand the basic structure of the XML schema for a rule, and how you can use this structure to define your custom sensitive information type so that it will identify the right content.

Een regel definieert een of meer entiteiten (typen voor vertrouwelijke gegevens) en elke entiteit definieert een of meer patronen.A rule defines one or more entities (sensitive information types), and each entity defines one or more patterns. Een patroon is waar beleid naar zoekt bij het evalueren van inhoud als e-mail en documenten.A pattern is what a policy looks for when it evaluates content such as email and documents.

In dit onderwerp worden in XML regels beschouwd als de patronen die een entiteit bepalen, ook wel bekend als een type voor vertrouwelijke gegevens.In this topic, the XML markup uses rule to mean the patterns that define an entity, also known as a sensitive information type. Dus wanneer u in dit onderwerp een regel ziet, denk dan aan entiteit of type voor vertrouwelijke gegevens en niet aan voorwaarden en acties.So in this topic, when you see rule, think entity or sensitive information type, not conditions and actions.

Eenvoudigste scenario: entiteit met één patroonSimplest scenario: entity with one pattern

Hier volgt het eenvoudigste scenario.Here's the simplest scenario. U wilt dat uw beleid de inhoud identificeert die de medewerkers-ID, die bestaat uit negen cijfers, van uw organisatie bevat.You want your policy to identify content that contains your organization's employee ID, which is formatted as a nine-digit number. Het patroon verwijst dus naar een normale expressie in de regel die getallen met negen cijfers identificeert.So the pattern refers to a regular expression contained in the rule that identifies nine-digit numbers. Alle inhoud met een getal van negen cijfers voldoet aan het patroon.Any content containing a nine-digit number satisfies the pattern.

Diagram van entiteit met één patroon

Hoewel het heel eenvoudig is, kan dit patroon veel fout-positieven identificeren door overeenkomende inhoud die een willekeurig negencijferig getal bevat dat niet noodzakelijkerwijs een medewerkers-ID is. However, while simple, this pattern may identify many false positives by matching content that contains any nine-digit number that is not necessarily an employee ID.

Vaker voorkomend scenario: entiteit met meerdere patronenMore common scenario: entity with multiple patterns

Daarom is het gebruikelijker een entiteit te definiëren door meer dan één patroon te gebruiken, waarbij de patronen niet alleen de entiteit identificeren (zoals een negencijferig getal), maar ook ondersteunende gegevens (zoals een trefwoord of datum).For this reason, it's more common to define an entity by using more than one pattern, where the patterns identify supporting evidence (such as a keyword or date) in addition to the entity (such as a nine-digit number).

Als u de waarschijnlijkheid wilt vergroten om inhoud te identificeren die een medewerkers-ID bevat, kunt u een ander patroon definiëren dat naast het negencijferige getal ook een aanstellingsdatum bevat en nog een ander patroon dat zowel de aanstellingsdatum als een trefwoord (zoals 'medewerkers-ID') identificeert.For example, to increase the likelihood of identifying content that contains an employee ID, you can define another pattern that also identifies a hire date, and define yet another pattern that identifies both a hire date and a keyword (such as "employee ID"), in addition to the nine-digit number.

Diagram van entiteit met meerdere patronen

Er zitten een aantal belangrijke aspecten aan deze structuur:Note a couple of important aspects of this structure:

  • Patronen die meer bewijs nodig hebben, hebben een hoger betrouwbaarheidsniveau.Patterns that require more evidence have a higher confidence level. Dit is handig, want wanneer u later dit type voor vertrouwelijke gegevens gebruikt in beleid kunt u meer beperkende acties gebruiken (zoals inhoud blokkeren) met alleen de overeenkomsten met een hogere betrouwbaarheid en minder beperkende acties (zoals het verzenden van een melding) bij overeenkomsten met een lagere betrouwbaarheid.This is useful because when you later use this sensitive information type in a policy, you can use more restrictive actions (such as block content) with only the higher-confidence matches, and you can use less restrictive actions (such as send notification) with the lower-confidence matches.

  • De ondersteunende IdMatch- en trefferelementen verwijzen naar regexes en trefwoorden die onderliggende elementen zijn van het regelelement, niet het patroon.The supporting IdMatch and Match elements reference regexes and keywords that are actually children of the Rule element, not the Pattern. Deze ondersteunende elementen worden aangeduid door het patroon, maar opgenomen in de regel.These supporting elements are referenced by the Pattern but included in the Rule. Dit betekent dat naar een enkele definitie van een ondersteunend element, zoals een normale expressie of een lijst met trefwoorden, kan worden verwezen door meerdere entiteiten en patronen.This means that a single definition of a supporting element, like a regular expression or a keyword list, can be referenced by multiple entities and patterns.

Welke entiteit moet u identificeren?What entity do you need to identify? [Entiteitselement, ID-kenmerk][Entity element, id attribute]

Een entiteit is een type voor vertrouwelijke gegevens, zoals een creditcardnummer, met een goed gedefinieerd patroon.An entity is a sensitive information type, such as a credit card number, that has a well-defined pattern. Elke entiteit heeft een unieke GUID als ID.Each entity has a unique GUID as its ID.

De entiteit een naam geven en de bijbehorende GUID genererenName the entity and generate its GUID

  1. Voeg in de XML-editor van uw keuze de regels en entiteitelementen toe.In your XML editor of choice, add the Rules and Entity elements.
  2. Voeg een opmerking toe waarin de naam van uw aangepaste entiteit staat, in dit voorbeeld Medewerkers-ID.Add a comment that contains the name of your custom entity — in this example, Employee ID. Later zult u de entiteitsnaam toevoegen aan het gedeelte met gelokaliseerde tekenreeksen en verschijnt de naam in de UI wanneer u beleid maakt.Later, you'll add the entity name to the localized strings section, and that name is what appears in the UI when you create a policy.
  3. Genereer een GUID voor uw entiteit.Generate a GUID for your entity. Er zijn verschillende manieren om GUID's te genereren, maar u kunt het eenvoudig in PowerShell doen door [guid]::NewGuid() te typen.There are several ways to generate GUIDs, but you can do it easily in PowerShell by typing [guid]::NewGuid(). Later voegt u ook de entiteits-GUID toe aan het gedeelte gelokaliseerde tekenreeksen.Later, you'll also add the entity GUID to the localized strings section.

XML met de elementen Regels en Entiteiten

Welk patroon wilt u vergelijken?What pattern do you want to match? [Patroonelement, IdMatch-element. Regex-element][Pattern element, IdMatch element, Regex element]

Het patroon bevat de lijst met waar het type voor vertrouwelijke gegevens naar zoekt.The pattern contains the list of what the sensitive information type is looking for. Dit kan regexes, trefwoorden en ingebouwde functies omvatten (die taken uitvoeren als het uitvoeren van regexes om datums of adressen te vinden).This can include regexes, keywords, and built-in functions (which perform tasks like running regexes to find dates or addresses). Typen voor vertrouwelijke gegevens kunnen meerdere patronen met unieke betrouwbaarheden.Sensitive information types can have multiple patterns with unique confidences.

Wat alle onderstaande patronen gemeen hebben is dat ze allemaal verwijzen naar dezelfde normale expressie die zoekt naar een negencijferig getal (\d{9}) omgeven door witruimte (\s)...What all of the below patterns have in common is that they all reference the same regular expression, which looks for a nine-digit number (\d{9}) surrounded by white space (\s) … (\s).(\s). Het element IdMatch verwijst naar deze normale expressie en de expressie is de algemene vereiste voor alle patronen die zoeken naar de entiteit Medewerkers-ID.This regular expression is referenced by the IdMatch element and is the common requirement for all patterns that look for the Employee ID entity. IdMatch is de aanduiding dat het patroon probeert te vinden, zoals Medewerkers-ID of creditcardnummer of burgerservicenummer.IdMatch is the identifier that the pattern is to trying to match, such as Employee ID or credit card number or social security number. Een patroonelement moet precies één IdMatch-element hebben.A Pattern element must have exactly one IdMatch element.

XML-opmaak met meerdere patroonelementen die verwijzen naar een enkel Regex-element

Wanneer aan de voorwaarden wordt voldaan, retourneert een patroon een telling en betrouwbaarheidsniveau die u kunt gebruiken in de voorwaarden in uw beleid.When satisfied, a pattern returns a count and confidence level, which you can use in the conditions in your policy. Wanneer u aan beleid een voorwaarde toevoegt voor de detectie van een type voor vertrouwelijke gegevens, kunt u de telling en het betrouwbaarheidsniveau bewerken, zoals hier wordt aangegeven.When you add a condition for detecting a sensitive information type to a policy, you can edit the count and confidence level as shown here. Het betrouwbaarheidsniveau (ook genaamd nauwkeurigheid van overeenkomst) wordt later in dit onderwerp uitgelegd.Confidence level (also called match accuracy) is explained later in this topic.

Opties voor de telling van exemplaren en nauwkeurigheid van overeenkomst

Wanneer u een normale expressie maakt, houd er dan rekening mee dat er potentiële problemen zijn waar u op moet letten.When you create your regular expression, keep in mind that there are potential issues to be aware of. Als u bijvoorbeeld een regex maakt en uploadt die te veel inhoud identificeert, kan dit van invloed zijn op de prestaties.For example, if you write and upload a regex that identifies too much content, this can impact performance. Zie Mogelijke validatieproblemen om op te letten verderop voor meer informatie over deze potentiële problemen.To learn more about these potential issues, see the later section Potential validation issues to be aware of.

Wilt u aanvullend bewijs eisen?Do you want to require additional evidence? [Trefferelement, minCount-kenmerk][Match element, minCount attribute]

Naast de IdMatch kan een patroon het trefferelement gebruiken om aanvullende ondersteunende gegevens te eisen, zoals een trefwoord, regex, datum of adres.In addition to the IdMatch, a pattern can use the Match element to require additional supporting evidence, such as a keyword, regex, date, or address.

Een patroon kan meerdere trefferelementen bevatten. Ze kunnen direct in het patroonelement worden opgenomen of gecombineerd door het Any-element te gebruiken.A Pattern can include multiple Match elements; they can be included directly in the Pattern element or combined by using the Any element. Trefferelementen worden gecombineerd door een impliciete AND-operator, er moet aan alle trefferelementen worden voldaan voordat het patroon overeenkomt.Match elements are joined by an implicit AND operator; all Match elements must be satisfied for the pattern to be matched. U kunt het Any-element gebruiken om AND- of OR-operatoren in te zetten (meer hierover in een later gedeelte).You can use the Any element to introduce AND or OR operators (more on that in a later section).

U kunt het optionele attribuut minCount gebruiken om op te geven hoeveel exemplaren van een overeenkomst moeten worden gevonden voor elk van de trefferelementen.You can use the optional minCount attribute to specify how many instances of a match need to be found for each of the Match elements. U kunt bijvoorbeeld specificeren dat pas aan een patroon wordt voldaan wanneer ten minste twee trefwoorden van een lijst met trefwoorden kunnen worden gevonden.For example, you can specify that a pattern is satisfied only when at least two keywords from a keyword list are found.

XML met trefferelement met attribuut minOccurs

Trefwoorden [trefwoord, groep en termelementen, matchStyle en caseSensitive-attributen]Keywords [Keyword, Group, and Term elements, matchStyle and caseSensitive attributes]

Wanneer u vertrouwelijke gegevens identificeert, zoals een medewerkers-ID, wilt u vaak trefwoorden eisen als ondersteunende gegevens.When you identify sensitive information, like an employee ID, you often want to require keywords as corroborative evidence. Zo kunt u bijvoorbeeld naast het zoeken naar een negencijferig nummber, zoeken naar woorden als 'kaart', 'badge' of 'ID'.For example, in addition to matching a nine-digit number, you may want to look for words like "card", "badge", or "ID". Hiervoor gebruikt u het element Trefwoord.To do this, you use the Keyword element. Het element Trefwoord heeft een ID-attribuut waarnaar kan worden verwezen door meerdere trefferelementen in meerdere patronen of entiteiten.The Keyword element has an ID attribute that can be referenced by multiple Match elements in multiple patterns or entities.

Trefwoorden worden opgenomen als een lijst van Termelementen in een Groepselement.Keywords are included as a list of Term elements in a Group element. Het Groepselement heeft een kenmerk matchStyle met twee mogelijke waarden:The Group element has a matchStyle attribute with two possible values:

  • matchStyle="word" een woordovereenkomst identificeert hele woorden omgeven door witruimte of andere scheidingstekens.matchStyle="word" Word match identifies whole words surrounded by white space or other delimiters. U moet altijd woord gebruiken tenzij u delen van woorden of woorden in Aziatische talen wilt vergelijken.You should always use word unless you need to match parts of words or match words in Asian languages.

  • matchStyle="string" een tekenreeksovereenkomst identificeert tekenreeksen, ongeacht waardoor ze worden omgeven.matchStyle="string" String match identifies strings no matter what they're surrounded by. 'id' komt bijvoorbeeld overeen met 'bid' en 'idee'.For example, "id" will match "bid" and "idea". Gebruik alleen tekenreeks wanneer u Aziatische woorden moet vergelijken of als uw trefwoord deel kan uitmaken van andere tekenreeksen.Use string only when you need to match Asian words or if your keyword may be included as part of other strings.

Tenslotte kunt u het kenmerk caseSensitive van het termelement gebruiken om op te geven dat de inhoud precies met het trefwoord moet overeenkomen, inclusief kleine en hoofdletters.Finally, you can use the caseSensitive attribute of the Term element to specify that the content must match the keyword exactly, including lower- and upper-case letters.

XML met overeenkomende elementen die verwijzen naar trefwoorden

Normale expressies [Regex-element]Regular expressions [Regex element]

In dit voorbeeld gebruikt de entiteit medewerkers-ID al het element IdMatch om te verwijzen naar een regex voor een patroon, een negencijferig getal omgeven door witruimte.In this example, the employee ID entity already uses the IdMatch element to reference a regex for the pattern — a nine-digit number surrounded by whitespace. Daarnaast kan een patroon een trefferelement gebruiken om te verwijzen naar een aanvullend regex-element om ondersteunende gegevens te identificeren, zoals een vijf- of negencijferig getal in de indeling van een Amerikaanse postcode.In addition, a pattern can use a Match element to reference an additional Regex element to identify corroborative evidence, such as a five- or nine-digit number in the format of a US zip code.

Aanvullende patronen, zoals datums of adressen [ingebouwde functies]Additional patterns such as dates or addresses [built-in functions]

Naast de ingebouwde typen voor vertrouwelijke gegevens, kunnen typen voor vertrouwelijke gegevens ook ingebouwde functies gebruiken die ondersteunende gegevens kunnen identificeren, zoals een Amerikaanse datum, Europese datum, vervaldatum of Amerikaans adres.In addition to the built-in sensitive information types, sensitive information types can also use built-in functions that can identify corroborative evidence such as a US date, EU date, expiration date, or US address. Microsoft 365 ondersteunt het uploaden van uw eigen aangepaste functies niet, maar wanneer u een aangepast type voor vertrouwelijke gegevens maakt, kan uw entiteit verwijzen naar de ingebouwde functies.Microsoft 365 does not support uploading your own custom functions, but when you create a custom sensitive information type, your entity can reference the built-in functions.

Een medewerkers-ID-badge heeft bijvoorbeeld een datum in dienst, dan kan deze aangepaste entiteit de ingebouwde functie gebruiken Func_us_dateeen datum identificeren in de indeling die normaliter in de VS wordt gebruikt.For example, an employee ID badge has a hire date on it, so this custom entity can use the built-in function Func_us_date to identify a date in the format commonly used in the US.

Zie Doel van de DLP-functies voor meer informatie.For more information, see What the DLP functions look for.

XML met trefferelement dat verwijst naar ingebouwde functie

Verschillende combinaties van bewijs [Any-element, minMatches- en maxMatches-kenmerken]Different combinations of evidence [Any element, minMatches and maxMatches attributes]

In een patroonelement worden alle IdMatch- en trefferelementen gecombineerd door een impliciete AND-operator, er moet aan alle voorwaarden worden voldaan voordat het patroon overeenkomt.In a Pattern element, all IdMatch and Match elements are joined by an implicit AND operator — all of the matches must be satisfied before the pattern can be satisfied. U kunt echter flexibelere overeenkomstlogica maken door het Any-element te gebruiken om trefferelementen te groeperen.However, you can create more flexible matching logic by using the Any element to group Match elements. U kunt bijvoorbeeld het Any-element gebruiken om alle, geen of een exacte subset van de onderliggende trefferelementen te vergelijken.For example, you can use the Any element to match all, none, or an exact subset of its children Match elements.

Het Any-element heeft optionele minMatches- en maxMatches-kenmerken die ukunt gebruiken om op te geven aan hoeveel van de onderliggende trefferelementen moet worden voldaan voordat het patroon overeenkomt.The Any element has optional minMatches and maxMatches attributes that you can use to define how many of the children Match elements must be satisfied before the pattern is matched. Houd er rekening mee dat deze kenmerken het aantal trefferelementen definiëren waaraan moet worden voldaan, niet het aantal exemplaren van bewijs dat wordt gevonden voor de overeenkomsten.Note that these attributes define the number of Match elements that must be satisfied, not the number of instances of evidence found for the matches. Om een minimaal aantal exemplaren op te geven voor een specifieke overeenkomst, zoals twee trefwoorden uit een lijst, gebruikt u het kenmerk minCount voor een trefferelement (zie hierboven).To define a minimum number of instances for a specific match, such as two keywords from a list, use the minCount attribute for a Match element (see above).

Ten minste één overeenkomend onderliggend trefferlementMatch at least one child Match element

Wanneer u wilt eisen dat er maar een minimaal aantal trefferelementen moet overeenkomen, kunt u het kenmerk minMatches gebruiken.If you want to require that only a minimum number of Match elements must be met, you can use the minMatches attribute. Deze trefferelementen worden in feite gecombineerd door een impliciete OR-operator.In effect, these Match elements are joined by an implicit OR operator. Aan dit Any-element wordt voldaan als een Amerikaanse datum of een trefwoord uit één van de lijsten wordt gevonden.This Any element is satisfied if a US-formatted date or a keyword from either list is found.

<Any minMatches="1" >
     <Match idRef="Func_us_date" />
     <Match idRef="Keyword_employee" />
     <Match idRef="Keyword_badge" />
</Any>

Een exact overeekomende subset van onderliggende trefferelementen Match an exact subset of any children Match elements

Als u wilt dat aan een exact aantal trefferelementen moet worden voldaan, kunt u minMatches en maxMatches op dezelfde waarde instellen.If you want to require that an exact number of Match elements must be met, you can set minMatches and maxMatches to the same value. Aan dit Any-element wordt alleen voldaan als precies één datum of trefwoord wordt gevonden, meer dan dat en het patroon komt niet overeen.This Any element is satisfied only if exactly one date or keyword is found — any more than that, and the pattern won't be matched.

<Any minMatches="1" maxMatches="1" >
     <Match idRef="Func_us_date" />
     <Match idRef="Keyword_employee" />
     <Match idRef="Keyword_badge" />
</Any>

Geen overeenkomende onderliggende trefferelementenMatch none of children Match elements

Wanneer u wilt eisen dat er geen bepaald bewijs wordt gevonden om aan een patroon te voldoen, kunt u minMatches en maxMatches beide op 0 instellen.If you want to require the absence of specific evidence for a pattern to be satisfied, you can set both minMatches and maxMatches to 0. Dit kan handig zijn wanneer u een lijst met trefwoorden hebt of ander bewijs dat waarschijnlijk duidt op een fout-positief.This can be useful if you have a keyword list or other evidence that are likely to indicate a false positive.

De entiteit medewerkers-ID zoekt bijvoorbeeld naar het trefwoord 'kaart', omdat dat mogelijk naar 'ID-kaart' verwijst.For example, the employee ID entity looks for the keyword "card" because it might refer to an "ID card". Als kaart echter alleen voorkomt in 'bankkaart', betekent 'kaart' in deze inhoud waarschijnlijk niet 'ID-kaart'.However, if card appears only in the phrase "credit card", "card" in this content is unlikely to mean "ID card". U kunt dus 'bankkaart' toevoegen als trefwoord in een lijst met termen die u wilt uitsluiten om aan het patroon te voldoen.So you can add "credit card" as a keyword to a list of terms that you want to exclude from satisfying the pattern.

<Any minMatches="0" maxMatches="0" >
    <Match idRef="Keyword_false_positives_local" />
    <Match idRef="Keyword_false_positives_intl" />
</Any>

Een aantal unieke overeenkomende termenMatch a number of unique terms

Wanneer u een aantal unieke termen wilt vergelijken, gebruikt u de parameter uniqueResults, ingesteld op waar, zoals weergegeven in het volgende voorbeeld:If you want to match a number of unique terms, use the uniqueResults parameter, set to true, as shown in the following example:

<Pattern confidenceLevel="75">
    <IdMatch idRef="Salary_Revision_terms" />
    <Match idRef=" Salary_Revision_ID " minCount="3" uniqueResults="true" />
</Pattern>

In dit voorbeeld is een patroon gedefinieerd voor een salariswijziging die gebruikmaakt van ten minste drie unieke overeenkomsten.In this example, a pattern is defined for salary revision using at least three unique matches.

Hoe dicht bij de entiteit moet het andere bewijs zijn?How close to the entity must the other evidence be? [patternsProximity-attribuut][patternsProximity attribute]

Uw type voor vertrouwelijke gegevens zoekt naar een patroon dat een medewerkers-ID vertegenwoordigt en als onderdeel van dat patroon zoekt het ook naar ondersteunende gegevens, zoals een trefwoord als 'ID'.Your sensitive information type is looking for a pattern that represents an employee ID, and as part of that pattern it's also looking for corroborative evidence like a keyword such as "ID". Het is logisch dat des te meer het bewijs overeenkomt, des te groter de kans is dat het patroon een medewerkers-ID is.It makes sense that the closer together this evidence is, the more likely the pattern is to be an actual employee ID. U kunt bepalen hoe dicht bij de entiteit het andere bewijs in het patroon moet zijn, door het vereiste attribuut patternsProximity van het entiteitselement te gebruiken.You can determine how close other evidence in the pattern must be to the entity by using the required patternsProximity attribute of the Entity element.

XML met attribuut patternsProximity

Voor elk patroon in de entiteit definieert de waarde van het attribuut patternsProximity de afstand (in Unicode-tekens) van de IdMatch-locatie voor alle andere overeenkomsten opgegeven voor dat patroon.For each pattern in the entity, the patternsProximity attribute value defines the distance (in Unicode characters) from the IdMatch location for all other Matches specified for that Pattern. De nabijheidsmarge is verankerd aan de IdMatch-locatie, waarbij de marge links en rechts van IdMatch kan worden uitgebreid.The proximity window is anchored by the IdMatch location, with the window extending to the left and right of the IdMatch.

Diagram van nabijheidsmarge

Onderstaande voorbeeld toont hoe de nabijheidsmargevan invloed is op de manier waarop IdMatch-element voor de aangepaste entiteit medewerkers-ID ten minste één overeenkomst van trefwoord of datum vereist.The example below illustrates how the proximity window affects the pattern matching where IdMatch element for the employee ID custom entity requires at least one corroborating match of keyword or date. Alleen ID1 komt overeen, omdat voor ID2 en ID3 geen of alleen gedeeltelijk ondersteunende gegevens kunnen worden gevonden binnen de nabijheidsmarge.Only ID1 matches because for ID2 and ID3, either no or only partial corroborating evidence is found within the proximity window.

Diagram van ondersteunende gegevens en nabijheidsmarge

Houd er rekening mee dat voor e-mailberichten, het bericht zelf en elke bijlage als afzonderlijke items worden behandeld.Note that for email, the message body and each attachment are treated as separate items. Dit betekent dat de nabijheidsmarge niet wordt uitgebreid na het einde van elk van deze items.This means that the proximity window does not extend beyond the end of each of these items. Voor elk item (bijlage of bericht) moeten zowel de IdMatch en ondersteunende gegevens zich in dat item bevinden.For each item (attachment or body), both the idMatch and corroborative evidence needs to reside in that item.

Wat zijn de juiste betrouwbaarheidsniveaus voor verschillende patronen?What are the right confidence levels for different patterns? [confidenceLevel-attribuut, recommendedConfidence-attribuut][confidenceLevel attribute, recommendedConfidence attribute]

Des te meer bewijs is vereist voor een patroon, des te betrouwbaarder het is dat een werkelijke entiteit (zoals medewerkers-ID) is geïdentificeerd wanneer het patroon overeenkomt.The more evidence that a pattern requires, the more confidence you have that an actual entity (such as employee ID) has been identified when the pattern is matched. U hebt bijvoorbeeld meer vertrouwen in een patroon dat een negencijferig ID-nummer, datum in dienst en trefwoord dicht bij elkaar vereist, dan in een patroon dat alleen een negencijferig ID-nummer vereist.For example, you have more confidence in a pattern that requires a nine-digit ID number, hire date, and keyword in close proximity, than you do in a pattern that requires only a nine-digit ID number.

Het patroonelement heeft een vereist kenmerk confidenceLevel.The Pattern element has a required confidenceLevel attribute. U kunt de waarde van confidenceLevel (een integer tussen 1 en 100) beschouwen als een uniek ID voor elk patroon in een entitei. De patronen in een entiteit moeten verschillende betrouwbaarheidsniveaus hebben die u toewijst.You can think of the value of confidenceLevel (an integer between 1 and 100) as a unique ID for each pattern in an entity — the patterns in an entity must have different confidence levels that you assign. De exacte waarde van de integer maakt niet uit, kies eenvoudig nummers die logisch zijn voor uw nalevingsteam.The precise value of the integer doesn't matter — simply pick numbers that make sense to your compliance team. Nadat u uw aangepaste type vertrouwelijke gegevens hebt geüpload en daarna beleid hebt gemaakt, kunt u naar deze betrouwbaarheidsniveaus verwijzen in de voorwaarden van de regels die u maakt.After you upload your custom sensitive information type and then create a policy, you can reference these confidence levels in the conditions of the rules that you create.

XML met patroonelementen met verschillende waarden voor het kenmerk confidenceLevel

Naast confidenceLevel voor elk patroon heeft de entiteit ook een kenmerk recommendedConfidence.In addition to confidenceLevel for each Pattern, the Entity has a recommendedConfidence attribute. Het kenmerk recommendedConfidence kan worden beschouwd als het standaardbetrouwbaarheidsniveau voor de regel.The recommended confidence attribute can be thought of as the default confidence level for the rule. Wanneer u een beleidsregel maakt, vergelijkt de regel op basis van het aanbevolen betrouwbaarheidsniveau voor de entiteit, tenzij u een betrouwbaarheidsniveau voor de regel opgeeft.When you create a rule in a policy, if you don't specify a confidence level for the rule to use, that rule will match based on the recommended confidence level for the entity. Houd er rekening mee dat het kenmerk recommendedConfidence verplicht is voor elke entiteits-ID in het regelpakket. Als het kenmerk ontbreekt, kunt u geen beleid opslaan dat gebruikmaakt van het type vertrouwelijke gegevens.Please note that the recommendedConfidence attribute is mandatory for each Entity ID in the Rule Package, if missing you won't be able to save policies that use the Sensitive Information Type.

Wilt u andere talen ondersteunen in de gebruikersinterface van het compliancecentrum?Do you want to support other languages in the UI of the Compliance center? [LocalizedStrings-element][LocalizedStrings element]

Als uw complianceteam het Microsoft 365-compliancecentrum gebruikt om beleid in verschillende landen en talen te maken, kunt u gelokaliseerde versies van de naam en beschrijving van uw aangepaste type vertrouwelijke gegevens geven.If your compliance team uses the Microsoft 365 Compliance center to create polices policies in different locales and in different languages, you can provide localized versions of the name and description of your custom sensitive information type. Wanneer uw complianceteam Microsoft 365 gebruikt in een taal die u ondersteunt, zien ze de gelokaliseerde naam in de gebruikersinterface.When your compliance team uses Microsoft 365 in a language that you support, they'll see the localized name in the UI.

Opties voor de telling van exemplaren en nauwkeurigheid van overeenkomst

Het element regels moet een LocalizedStrings-element bevatten, dat een Resource-element bevat dat verwijst naar de GUID van uw aangepaste entiteit.The Rules element must contain a LocalizedStrings element, which contains a Resource element that references the GUID of your custom entity. Elk Resource-element bevat een of meer Naam- en Beschrijving-elementen die elk het kenmerk taalcode gebruiken om een gelokaliseerde tekenreeks te geven voor een specifieke taal.In turn, each Resource element contains one or more Name and Description elements that each use the langcode attribute to provide a localized string for a specific language.

XML met inhoud van LocalizedStrings-element

Houd er rekening mee dat u gelokaliseerde tekenreeksen alleen gebruikt om te bepalen hoe uw aangepaste type vertrouwelijke gegevens wordt weergegeven in de gebruikersinterface van het compliancecentrum.Note that you use localized strings only for how your custom sensitive information type appears in the UI of the Compliance center. U kunt gelokaliseerde tekenreeksen niet gebruiken om verschillende gelokaliseerde versies van een lijst trefwoorden of normale expressie te bieden.You can't use localized strings to provide different localized versions of a keyword list or regular expression.

Ander regelpakket [RulePack GUID]Other rule package markup [RulePack GUID]

Ten slotte bevat het begin van elk RulePackage algemene gegevens die u moet invullen.Finally, the beginning of each RulePackage contains some general information that you need to fill in. U kunt de volgende tekst gebruiken als sjabloon en de " You can use the following markup as a template and replace the ". .. ."." vervangen met tijdelijke aanduidingen met uw eigen gegevens.placeholders with your own info.

Het belangrijkste is dat u een GUID moet genereren voor het RulePack.Most importantly, you'll need to generate a GUID for the RulePack. Hierboven hebt u een GUID gegenereerd voor de entiteit, dit is een tweede GUID voor het RulePack.Above, you generated a GUID for the entity; this is a second GUID for the RulePack. Er zijn verschillende manieren om GUID's te genereren, maar u kunt het eenvoudig in PowerShell doen door [guid]::NewGuid() te typen.There are several ways to generate GUIDs, but you can do it easily in PowerShell by typing [guid]::NewGuid().

Het element Versie is ook belangrijk.The Version element is also important. WAnneer u uw regelpakket de eerste keer upload, wordt in Microsoft 365 het versienummer genoteerd.When you upload your rule package for the first time, Microsoft 365 notes the version number. Later, wanneer u het regelpakket bijwerkt en een nieuwe versie uploadt, zorg er dan voor dat u het versienummer bijwerkt, anders implementeert Microsoft 365 het regelpakket niet.Later, if you update the rule package and upload a new version, make sure to update the version number or Microsoft 365 won't deploy the rule package.

<?xml version="1.0" encoding="utf-16"?>
<RulePackage xmlns="http://schemas.microsoft.com/office/2011/mce">
  <RulePack id=". . .">
    <Version major="1" minor="0" build="0" revision="0" />
    <Publisher id=". . ." /> 
    <Details defaultLangCode=". . .">
      <LocalizedDetails langcode=" . . . ">
         <PublisherName>. . .</PublisherName>
         <Name>. . .</Name>
         <Description>. . .</Description>
      </LocalizedDetails>
    </Details>
  </RulePack>
  
 <Rules>
    . . .
 </Rules>
</RulePackage>

Wanneer het klaar is, zou uw RulePack-element er als volgt uit moeten zien.When complete, your RulePack element should look like this.

XML met RulePack-element

Wijzigingen voor Exchange OnlineChanges for Exchange Online

Voorheen gebruikte u mogelijk Exchange Online PowerShell om uw aangepaste typen vertrouwelijke gegevens voor DLP te importeren.Previously, you might have used Exchange Online PowerShell to import your custom sensitive information types for DLP. Nu kunnen uw typen vertrouwelijke gegevens worden gebruikt in zowel het Exchange-beheercentrum als het compliancecentrum.Now your custom sensitive information types can be used in both the Exchange admin center and the Compliance center. Als onderdeel van deze verbetering moet u compliancecentrum PowerShell gebruiken om uw aangepaste typen vertrouwelijke gegevens te importeren, u kunt ze niet meer importeren vanuit Exchange PowerShell.As part of this improvement, you should use Compliance center PowerShell to import your custom sensitive information types — you can't import them from the Exchange PowerShell anymore. Uw aangepaste typen vertrouwelijke gegevens blijven gewoon werken als voorheen, het kan echter maximaal een uur duren voordat wijzigingen die zijn aangebracht aan typen vertrouwelijke gegevens in het compliancecentrum verschijnen in het Exchange-beheercentrum.Your custom sensitive information types will continue to work just like before; however, it may take up to one hour for changes made to custom sensitive information types in the Compliance center to appear in the Exchange admin center.

Houd er rekening mee dat u in het compliancecentrum de cmdlet New-DlpSensitiveInformationTypeRulePackage gebruikt om een regelpakket te uploaden.Note that in the Compliance center, you use the New-DlpSensitiveInformationTypeRulePackage cmdlet to upload a rule package. (Voorheen in het Exchange-beheercentrum gebruikte u de cmdlet ClassificationRuleCollection.)(Previously, in the Exchange admin center, you used the ClassificationRuleCollection` cmdlet.)

Uw regelpakket uploadenUpload your rule package

Om uw regelpakket te uploaden, moet u de volgende stappen uitvoeren:To upload your rule package, do the following steps:

  1. Het pakket opslaan als .XML-bestand met Unicode-codering.Save it as an .xml file with Unicode encoding.

  2. Verbinding maken met compliancecentrum PowerShellConnect to Compliance center PowerShell

  3. Gebruik de volgende syntaxis:Use the following syntax:

    New-DlpSensitiveInformationTypeRulePackage -FileData (Get-Content -Path "PathToUnicodeXMLFile" -Encoding Byte -ReadCount 0)
    

    In dit voorbeeld wordt het Unicode XML-bestand met de naam MyNewRulePack.xml geüpload vanaf C:\Mijn documenten.This example uploads the Unicode XML file named MyNewRulePack.xml from C:\My Documents.

    New-DlpSensitiveInformationTypeRulePackage -FileData (Get-Content -Path "C:\My Documents\MyNewRulePack.xml" -Encoding Byte -ReadCount 0)
    

    Zie New-DlpSensitiveInformationTypeRulePackage voor meer gedetailleerde syntaxis- en parameterinformatie.For detailed syntax and parameter information, see New-DlpSensitiveInformationTypeRulePackage.

    Notitie

    Er worden maximaal 10 regelpakketten ondersteund, maar ieder pakket kan de definitie van meerdere typen vertrouwelijke gegevens bevatten.The maximum number of rule packages supported is 10, but each package can contain the definition of multiple sensitive information types.

  4. Voer een van de volgende stappen uit om er zeker van te zijn dat u een nieuw type vertrouwelijke gegevens hebt gemaakt:To verify that you've successfully created a new sensitive information type, do any of the following steps:

    • Voer de cmdlet Get-DlpSensitiveInformationTypeRulePackage uit om te verifiëren dat het nieuwe regelpakket op de lijst wordt vermeld:Run the Get-DlpSensitiveInformationTypeRulePackage cmdlet to verify the new rule package is listed:

      Get-DlpSensitiveInformationTypeRulePackage
      
    • Voer de cmdlet Get-DlpSensitiveInformationType uit om te verifiëren dat het nieuwe regelpakket op de lijst wordt vermeld:Run the Get-DlpSensitiveInformationType cmdlet to verify the sensitive information type is listed:

      Get-DlpSensitiveInformationType
      

      Voor aangepaste typen vertrouwelijke gegevens wordt de waarde van de eigenschap Uitgever iets anders dan Microsoft Corporation.For custom sensitive information types, the Publisher property value will be something other than Microsoft Corporation.

    • Vervang <Name> met de Naamwaarde van het type vertrouwelijke gegevens (bijvoorbeeld: Medewerkers-ID) en voer de cmdlet Get-DlpSensitiveInformationType uit:Replace <Name> with the Name value of the sensitive information type (example: Employee ID) and run the Get-DlpSensitiveInformationType cmdlet:

      Get-DlpSensitiveInformationType -Identity "<Name>"
      

Mogelijke validatieproblemen om rekening mee te houdenPotential validation issues to be aware of

Wanneer u uw regelpakket-XML-bestand uploadt, wordt door het systeem de XML gevalideerd en gecontroleerd op bekende onjuiste patronen en voor de hand liggende prestatieproblemen.When you upload your rule package XML file, the system validates the XML and checks for known bad patterns and obvious performance issues. Hier zijn een aantal bekende problemen waar de validatie op controleert, een normale expressie:Here are some known issues that the validation checks for — a regular expression:

  • mag niet beginnen of eindigen met een "|" die overeenkomt met alles, omdat het wordt beschouwd als lege overeenkomst.Cannot begin or end with alternator "|", which matches everything because it's considered an empty match.

    Bijvoorbeeld: "|a" of "|b" komt niet door de validatie.For example, "|a" or "b|" will not pass validation.

  • mag niet beginnen of eindigen met een ".{0,}"-patroon dat geen functioneel doel heeft en alleen de prestatie nadelig beïnvloedt.Cannot begin or end with a ".{0,m}" pattern, which has no functional purpose and only impairs performance.

    Bijvoorbeeld: ".{0,50}ASDF" or "ASDF.{0,50}" komt niet door de validatie.For example, ".{0,50}ASDF" or "ASDF.{0,50}" will not pass validation.

  • mag geen ".{0,m}" of ".{1,m}" in groepen hebben en geen ".*" or ".+" in groepen.Cannot have ".{0,m}" or ".{1,m}" in groups, and cannot have ".*" or ".+" in groups.

    Bijvoorbeeld: "(.{0,50000})" komt niet door de validatie.For example, "(.{0,50000})" will not pass validation.

  • mag geen tekens hebben met "{0,m}"- of "{1,m}"-herhalingen in groepen. Cannot have any character with "{0,m}" or "{1,m}" repeaters in groups.

    Bijvoorbeeld: "(a*)" komt niet door de validatie.For example, "(a*)" will not pass validation.

  • mag niet beginnen of eindigen met ".{1,m}", gebruik hiervoor in de plaats gewoon "."Cannot begin or end with ".{1,m}"; instead, use just "."

    Bijvoorbeeld: ".{1,m}asdf" komt niet door de validatie, gebruik in plaats daarvan ".asdf".For example, ".{1,m}asdf" will not pass validation; instead, use just ".asdf".

  • mag geen onafhankelijke herhaling (zoals "*" of "+") hebben in een groep.Cannot have an unbounded repeater (such as "*" or "+") on a group.

    Bijvoorbeeld: "(xx)*" en "(xx)+" komen niet door de validatie.For example, "(xx)*" and "(xx)+" will not pass validation.

  • Trefwoorden mogen maximaal 50 tekens lang zijn.Keywords have a maximum of 50 characters in Length. Als u in een groep een trefwoord hebt dat langer is, wordt voorgesteld een groep met termen te maken als een trefwoordenlijst en de GUID van de trefwoordenboek te verwijzen binnen de XML-structuur als onderdeel van de entiteit voor overeenkomst of idMatch in het bestand.If you have a keyword within a Group exceeding this, a suggested solution is to create the Group of terms as a Keyword Dictionary and reference the GUID of the Keyword Dictionary within the XML structure as part of the Entity for Match or idMatch in the file.

  • Elk aangepaste type vertrouwelijke gegevens mag maximaal 2048 trefwoorden hebben.Each Custom Sensitive Information Type can have a maximum of 2048 keywords total.

  • De maximale grootte van trefwoordenboeken in een enkele tenant is 1 MB gecomprimeerd.The maximum size of Keyword Dictionaries in a single tenant is 1 MB compressed. Verwijs zo vaak als nodig is naar hetzelfde boek bij het maken van typen vertrouwelijke gegevens.Reference the same dictionary as many times as necessary when creating custom sensitive information types. Begin met het maken van aangepaste trefwoordenlijsten in het type vertrouwelijke gegevens en gebruik trefwoordenboeken als u meer dan 2048 trefwoord in een trefwoordenlijst hebt of als een trefwoord langer is dan 50 tekens.Start with creating custom keyword lists in the sensitive information type and use keyword dictionaries if you have more than 2048 keywords in a keyword list or a keyword is larger than 50 characters in length.

  • Er zijn maximaal 50 typen vertrouwelijke gegevens op basis van trefwoordenboeken toegestaan in een tenant.A maximum of 50 keyword dictionary based sensitive information types are allowed in a tenant.

  • Zorg ervoor dat elke entiteitselement een kenmerk recommendedConfidence bevat.Ensure each Entity element contains a recommendedConfidence attribute.

  • Bij het gebruik van de cmdlet PowerShell is er een maximale retourgrootte van de gedeserialiseerde gegevens van ongeveer 1 megabyte.When using the PowerShell Cmdlet there is a maximum return size of the Deserialized Data of approximately 1 megabyte. Dit is van invloed op de grootte van het XML-bestand van uw regelpakket.This will affect the size of your rule pack XML file. Houd het geüploade bestand beperkt tot maximaal 770 kilobyte, als voorgestelde limiet voor consistente resultaten zonder fouten tijdens de uitvoering.Keep the uploaded file limited to a 770 kilobyte maximum as a suggested limit for consistent results without error when processing.

  • De XML-structuur vereist geen opmaaktekens zoals spaties, tabs of Enter-tekens.The XML structure does not require formatting characters such as spaces, tabs, or carriage return/linefeed entries. Houd hier rekening mee bij het optimaliseren van ruimte voor uploads.Take note of this when optimizing for space on uploads. Hulpprogramma's zoals Microsoft Visual Code bieden join-lijnfuncties om het XML-bestand te comprimeren.Tools such as Microsoft Visual Code provide join line features to compact the XML file.

Als een aangepast type vertrouwelijke gegevens een probleem bevat dat de prestaties kan beïnvloeden, wordt het niet geüpload en krijgt u mogelijk een van deze foutberichten te zien:If a custom sensitive information type contains an issue that may affect performance, it won't be uploaded and you may see one of these error messages:

  • Algemene bepalers komen overeen met meer inhoud dan verwacht (bijvoorbeeld '+', '*')Generic quantifiers which match more content than expected (e.g., '+', '*')

  • Lookaround assertionsLookaround assertions

  • Gecompliceerde groepering in combinatie met algemene bepalersComplex grouping in conjunction with general quantifiers

Uw inhoud opnieuw bekijken om de vertrouwelijke gegevens te identificerenRecrawl your content to identify the sensitive information

Microsoft 365 gebruikt de zoekverkenner om vertrouwelijke gegevens te identificeren en te classificeren in site-inhoud.Microsoft 365 uses the search crawler to identify and classify sensitive information in site content. Inhoud in SharePoint Online- en OneDrive Bedrijven-sites wordt automatisch opnieuw verkend bij het bijwerken.Content in SharePoint Online and OneDrive for Business sites is recrawled automatically whenever it's updated. Maar om uw nieuwe aangepaste type vertrouwelijke gegevens te identificeren in alle bestaande inhoud, moet die inhoud opnieuw worden verkend.But to identify your new custom type of sensitive information in all existing content, that content must be recrawled.

In Microsoft 365 kunt u niet handmatig de verkenning van een hele tenant aanvragen, maar u kunt dit wel doen voor een siteverzameling, lijst of bibliotheek. Zie Het verkennen en opnieuw indexeren van een site, bibliotheek of lijst handmatig aanvragen.In Microsoft 365, you can't manually request a recrawl of an entire tenant, but you can do this for a site collection, list, or library — see Manually request crawling and re-indexing of a site, a library or a list.

Een aangepast type vertrouwelijke gegevens verwijderenRemove a custom sensitive information type

Notitie

Controleer voordat u een aangepast type vertrouwelijke gegevens verwijdert dat er geen DLP-beleid of Exchange-berichtenstroomregels (ook wel transportregels genoemd) meer verwijzen naar het type vertrouwelijke gegevens.Before your remove a custom sensitive information type, verify that no DLP policies or Exchange mail flow rules (also known as transport rules) still reference the sensitive information type.

In compliancecentrum PowerShell zijn er twee methoden om aangepaste typen vertrouwelijke gegevens te verwijderen:In Compliance center PowerShell, there are two methods to remove custom sensitive information types:

  • Afzonderlijke aangepaste type vertrouwelijke gegevens verwijderen: gebruik de methode die wordt beschreven in Een aangepast type vertrouwelijke gegevens bewerken.Remove individual custom sensitive information types: Use the method documented in Modify a custom sensitive information type. U exporteert het aangepaste regelpakket dat het aangepaste type vertrouwelijke gegevens bevat, verwijdert het type vertrouwelijke gegevens uit het XML-bestand en importeert het bijgewerkte XML-bestand in het bestaande aangepaste regelpakket.You export the custom rule package that contains the custom sensitive information type, remove the sensitive information type from the XML file, and import the updated XML file back into the existing custom rule package.

  • Een aangepast regelpakket en alle aangepaste typen vertrouwelijke gegevens die het bevat, verwijderen: deze methode wordt in dit gedeelte beschreven.Remove a custom rule package and all custom sensitive information types that it contains: This method is documented in this section.

  1. Verbinding maken met compliancecentrum PowerShellConnect to Compliance center PowerShell

  2. Om een aangepast regelpakket te verwijderen, gebruikt u de cmdlet Remove-DlpSensitiveInformationTypeRulePackage:To remove a custom rule package, use the Remove-DlpSensitiveInformationTypeRulePackage cmdlet:

    Remove-DlpSensitiveInformationTypeRulePackage -Identity "RulePackageIdentity"
    

    U kunt de naamwaarde (voor elke taal) gebruiken of de RulePack id-waarde (GUID) om het regelpakket te identificeren.You can use the Name value (for any language) or the RulePack id (GUID) value to identify the rule package.

    In dit voorbeeld wordt het regelpakket met de naam 'Medewerkers-ID aangepast regelpakket' verwijderd.This example removes the rule package named "Employee ID Custom Rule Pack".

    Remove-DlpSensitiveInformationTypeRulePackage -Identity "Employee ID Custom Rule Pack"
    

    Zie Remove-DlpSensitiveInformationTypeRulePackage voor meer gedetailleerde syntaxis- en parameterinformatie.For detailed syntax and parameter information, see Remove-DlpSensitiveInformationTypeRulePackage.

  3. Voer een van de volgende stappen uit om er zeker van te zijn dat u een aangepast type vertrouwelijke gegevens hebt verwijderd:To verify that you've successfully removed a custom sensitive information type, do any of the following steps:

    • Voer de cmdlet Get-DlpSensitiveInformationTypeRulePackage uit en controleer dat het regelpakket niet meer in de lijst wordt vermeld:Run the Get-DlpSensitiveInformationTypeRulePackage cmdlet and verify the rule package is no longer listed:

      Get-DlpSensitiveInformationTypeRulePackage
      
    • Voer de cmdlet Get-DlpSensitiveInformationType uit om te verifiëren dat de typen vertrouwelijke gegevens in het verwijderde regelpakket niet meer in de lijst worden vermeld:Run the Get-DlpSensitiveInformationType cmdlet to verify the sensitive information types in the removed rule package are no longer listed:

      Get-DlpSensitiveInformationType
      

      Voor aangepaste typen vertrouwelijke gegevens wordt de waarde van de eigenschap Uitgever iets anders dan Microsoft Corporation.For custom sensitive information types, the Publisher property value will be something other than Microsoft Corporation.

    • Vervang <Name> met de naamwaarde van het type vertrouwelijke gegevens (bijvoorbeeld Medewerkers-ID) en voer de cmdlet Get-DlpSensitiveInformationType uit om te verifiëren dat het type vertrouwelijke gegevens niet meer in de lijst wordt vermeld:Replace <Name> with the Name value of the sensitive information type (for example, Employee ID) and run the Get-DlpSensitiveInformationType cmdlet to verify the sensitive information type is no longer listed:

      Get-DlpSensitiveInformationType -Identity "<Name>"
      

Een aangepast type vertrouwelijke gegevens bewerkenModify a custom sensitive information type

Om in compliancecentrum PowerShell een aangepast type vertrouwelijke gegevens te bewerken, moet u:In Compliance center PowerShell, modifying a custom sensitive information type requires you to:

  1. het bestaande regelpakket dat het aangepaste type vertrouwelijke gegevens bevat exporteren naar een XML-bestand (of het bestaande XML-bestand gebruiken als u dat hebt).Export the existing rule package that contains the custom sensitive information type to an XML file (or use the existing XML file if you have it).

  2. het aangepaste type vertrouwelijke gegevens in het geëxporteerde XML-bestand bewerken.Modify the custom sensitive information type in the exported XML file.

  3. het bijgewerkte XML-bestand importeren in het bestaande regelpakket.Import the updated XML file back into the existing rule package.

Zie Verbinding maken met compliancecentrum PowerShell om verbinding te maken met compliancecentrum PowerShell. To connect to Compliance Center PowerShell, see Connect to Compliance Center PowerShell.

Stap 1: Het bestaande regelpakket exporteren naar een XML-bestandStep 1: Export the existing rule package to an XML file

Notitie

Als u een kopie van het XML-bestand hebt (bijvoorbeeld als u het net hebt gemaakt en geïmporteerd) kunt u verdergaan met de volgende stap om het XML-bestand te bewerken.If you have a copy of the XML file (for example, you just created and imported it), you can skip to the next step to modify the XML file.

  1. Voer de cmdlet Get-DlpSensitiveInformationTypeRulePackage uit om de naam van het aangepaste regelpakket te vinden als u die nog niet weet:If you don't already know it, run the Get-DlpSensitiveInformationTypeRulePackage cmdlet to find the name of the custom rule package:

    Get-DlpSensitiveInformationTypeRulePackage
    

    Notitie

    Het ingebouwde regelpakket dat de ingebouwde typen vertrouwelijke gegevens bevat heet Microsoft Regelpakket.The built-in rule package that contains the built-in sensitive information types is named Microsoft Rule Package. Het regelpakket dat de aangepaste typen vertrouwelijke gegevens bevat die u hebt gemaakt in de compliancecentrum-gebruikersinterface heet Microsoft.SCCManaged.CustomRulePack.The rule package that contains the custom sensitive information types that you created in the Compliance center UI is named Microsoft.SCCManaged.CustomRulePack.

  2. Gebruik de cmdlet Get-DlpSensitiveInformationTypeRulePackage om het aangepaste regelpakket op te slaan in een variabele:Use the Get-DlpSensitiveInformationTypeRulePackage cmdlet to store the custom rule package to a variable:

    $rulepak = Get-DlpSensitiveInformationTypeRulePackage -Identity "RulePackageName"
    

    Als de naam van het regelpakket bijvoorbeeld 'Medewerkers-ID aangepast regelpakket' is, voert u de volgende cmdlet uit:For example, if the name of the rule package is "Employee ID Custom Rule Pack", run the following cmdlet:

    $rulepak = Get-DlpSensitiveInformationTypeRulePackage -Identity "Employee ID Custom Rule Pack"
    
  3. Gebruik de cmdlet Set-Content om het aangepaste regelpakket te exporteren naar een XML-bestand:Use the Set-Content cmdlet to export the custom rule package to an XML file:

    Set-Content -Path "XMLFileAndPath" -Encoding Byte -Value $rulepak.SerializedClassificationRuleCollection
    

    In dit voorbeeld wordt het regelpakket geëxporteerd naar een bestand met de naam ExportedRulePackage.xml in de map C:\Mijn documenten.This example export the rule package to the file named ExportedRulePackage.xml in the C:\My Documents folder.

    Set-Content -Path "C:\My Documents\ExportedRulePackage.xml" -Encoding Byte -Value $rulepak.SerializedClassificationRuleCollection
    

Stap 2: het type vertrouwelijke gegevens in het geëxporteerde XML-bestand bewerkenStep 2: Modify the sensitive information type in the exported XML file

Typen vertrouwelijke gegevens in het XML-bestand en andere elementen in het bestand worden eerder in dit onderwerp beschreven.Sensitive information types in the XML file and other elements in the file are described earlier in this topic.

Stap 3: het bijgewerkte XML-bestand importeren in het bestaande regelpakketStep 3: Import the updated XML file back into the existing rule package

Gebruik de cmdlet Set-DlpSensitiveInformationTypeRulePackage om het bijgewerkte XML-bestand te importeren in het bestaande regelpakket:To import the updated XML back into the existing rule package, use the Set-DlpSensitiveInformationTypeRulePackage cmdlet:

Set-DlpSensitiveInformationTypeRulePackage -FileData ([Byte[]]$(Get-Content -Path "C:\My Documents\External Sensitive Info Type Rule Collection.xml" -Encoding Byte -ReadCount 0))

Zie Set-DlpSensitiveInformationTypeRulePackage voor meer gedetailleerde syntaxis- en parameterinformatie.For detailed syntax and parameter information, see Set-DlpSensitiveInformationTypeRulePackage.

Verwijzing: definitie van het XML-schema van het regelpakketReference: Rule package XML schema definition

U kunt deze tekst kopiëren, opslaan als XSD-bestand en gebruiken om het XML-bestand van uw regelpakket te valideren.You can copy this markup, save it as an XSD file, and use it to validate your rule package XML file.

<?xml version="1.0" encoding="utf-8"?>
<xs:schema xmlns:mce="http://schemas.microsoft.com/office/2011/mce"
           targetNamespace="http://schemas.microsoft.com/office/2011/mce"
           xmlns:xs="https://www.w3.org/2001/XMLSchema"
           elementFormDefault="qualified"
           attributeFormDefault="unqualified"
           id="RulePackageSchema">
  <!-- Use include if this schema has the same target namespace as the schema being referenced, otherwise use import -->
  <xs:element name="RulePackage" type="mce:RulePackageType"/>
  <xs:simpleType name="LangType">
    <xs:union memberTypes="xs:language">
      <xs:simpleType>
        <xs:restriction base="xs:string">
          <xs:enumeration value=""/>
        </xs:restriction>
      </xs:simpleType>
    </xs:union>
  </xs:simpleType>
  <xs:simpleType name="GuidType" final="#all">
    <xs:restriction base="xs:token">
      <xs:pattern value="[0-9a-fA-F]{8}\-([0-9a-fA-F]{4}\-){3}[0-9a-fA-F]{12}"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="RulePackageType">
    <xs:sequence>
      <xs:element name="RulePack" type="mce:RulePackType"/>
      <xs:element name="Rules" type="mce:RulesType">
        <xs:key name="UniqueRuleId">
          <xs:selector xpath="mce:Entity|mce:Affinity|mce:Version/mce:Entity|mce:Version/mce:Affinity"/>
          <xs:field xpath="@id"/>
        </xs:key>
        <xs:key name="UniqueProcessorId">
          <xs:selector xpath="mce:Regex|mce:Keyword|mce:Fingerprint"></xs:selector>
          <xs:field xpath="@id"/>
        </xs:key>
        <xs:key name="UniqueResourceIdRef">
          <xs:selector xpath="mce:LocalizedStrings/mce:Resource"/>
          <xs:field xpath="@idRef"/>
        </xs:key>
        <xs:keyref name="ReferencedRuleMustExist" refer="mce:UniqueRuleId">
          <xs:selector xpath="mce:LocalizedStrings/mce:Resource"/>
          <xs:field xpath="@idRef"/>
        </xs:keyref>
        <xs:keyref name="RuleMustHaveResource" refer="mce:UniqueResourceIdRef">
          <xs:selector xpath="mce:Entity|mce:Affinity|mce:Version/mce:Entity|mce:Version/mce:Affinity"/>
          <xs:field xpath="@id"/>
        </xs:keyref>
      </xs:element>
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="RulePackType">
    <xs:sequence>
      <xs:element name="Version" type="mce:VersionType"/>
      <xs:element name="Publisher" type="mce:PublisherType"/>
      <xs:element name="Details" type="mce:DetailsType">
        <xs:key name="UniqueLangCodeInLocalizedDetails">
          <xs:selector xpath="mce:LocalizedDetails"/>
          <xs:field xpath="@langcode"/>
        </xs:key>
        <xs:keyref name="DefaultLangCodeMustExist" refer="mce:UniqueLangCodeInLocalizedDetails">
          <xs:selector xpath="."/>
          <xs:field xpath="@defaultLangCode"/>
        </xs:keyref>
      </xs:element>
      <xs:element name="Encryption" type="mce:EncryptionType" minOccurs="0" maxOccurs="1"/>
    </xs:sequence>
    <xs:attribute name="id" type="mce:GuidType" use="required"/>
  </xs:complexType>
  <xs:complexType name="VersionType">
    <xs:attribute name="major" type="xs:unsignedShort" use="required"/>
    <xs:attribute name="minor" type="xs:unsignedShort" use="required"/>
    <xs:attribute name="build" type="xs:unsignedShort" use="required"/>
    <xs:attribute name="revision" type="xs:unsignedShort" use="required"/>
  </xs:complexType>
  <xs:complexType name="PublisherType">
    <xs:attribute name="id" type="mce:GuidType" use="required"/>
  </xs:complexType>
  <xs:complexType name="LocalizedDetailsType">
    <xs:sequence>
      <xs:element name="PublisherName" type="mce:NameType"/>
      <xs:element name="Name" type="mce:RulePackNameType"/>
      <xs:element name="Description" type="mce:OptionalNameType"/>
    </xs:sequence>
    <xs:attribute name="langcode" type="mce:LangType" use="required"/>
  </xs:complexType>
  <xs:complexType name="DetailsType">
    <xs:sequence>
      <xs:element name="LocalizedDetails" type="mce:LocalizedDetailsType" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="defaultLangCode" type="mce:LangType" use="required"/>
  </xs:complexType>
  <xs:complexType name="EncryptionType">
    <xs:sequence>
      <xs:element name="Key" type="xs:normalizedString"/>
      <xs:element name="IV" type="xs:normalizedString"/>
    </xs:sequence>
  </xs:complexType>
  <xs:simpleType name="RulePackNameType">
    <xs:restriction base="xs:token">
      <xs:minLength value="1"/>
      <xs:maxLength value="64"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="NameType">
    <xs:restriction base="xs:normalizedString">
      <xs:minLength value="1"/>
      <xs:maxLength value="256"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="OptionalNameType">
    <xs:restriction base="xs:normalizedString">
      <xs:minLength value="0"/>
      <xs:maxLength value="256"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="RestrictedTermType">
    <xs:restriction base="xs:string">
      <xs:minLength value="1"/>
      <xs:maxLength value="100"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="RulesType">
    <xs:sequence>
      <xs:choice maxOccurs="unbounded">
        <xs:element name="Entity" type="mce:EntityType"/>
        <xs:element name="Affinity" type="mce:AffinityType"/>
        <xs:element name="Version" type="mce:VersionedRuleType"/>
      </xs:choice>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element name="Regex" type="mce:RegexType"/>
        <xs:element name="Keyword" type="mce:KeywordType"/>
        <xs:element name="Fingerprint" type="mce:FingerprintType"/>
        <xs:element name="ExtendedKeyword" type="mce:ExtendedKeywordType"/>
      </xs:choice>
      <xs:element name="LocalizedStrings" type="mce:LocalizedStringsType"/>
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="EntityType">
    <xs:sequence>
      <xs:element name="Pattern" type="mce:PatternType" maxOccurs="unbounded"/>
      <xs:element name="Version" type="mce:VersionedPatternType" minOccurs="0" maxOccurs="unbounded" />
    </xs:sequence>
    <xs:attribute name="id" type="mce:GuidType" use="required"/>
    <xs:attribute name="patternsProximity" type="mce:ProximityType" use="required"/>
    <xs:attribute name="recommendedConfidence" type="mce:ProbabilityType"/>
    <xs:attribute name="workload" type="mce:WorkloadType"/>
  </xs:complexType>
  <xs:complexType name="PatternType">
    <xs:sequence>
      <xs:element name="IdMatch" type="mce:IdMatchType"/>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element name="Match" type="mce:MatchType"/>
        <xs:element name="Any" type="mce:AnyType"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="confidenceLevel" type="mce:ProbabilityType" use="required"/>
  </xs:complexType>
  <xs:complexType name="AffinityType">
    <xs:sequence>
      <xs:element name="Evidence" type="mce:EvidenceType" maxOccurs="unbounded"/>
      <xs:element name="Version" type="mce:VersionedEvidenceType" minOccurs="0" maxOccurs="unbounded" />
    </xs:sequence>
    <xs:attribute name="id" type="mce:GuidType" use="required"/>
    <xs:attribute name="evidencesProximity" type="mce:ProximityType" use="required"/>
    <xs:attribute name="thresholdConfidenceLevel" type="mce:ProbabilityType" use="required"/>
    <xs:attribute name="workload" type="mce:WorkloadType"/>
  </xs:complexType>
  <xs:complexType name="EvidenceType">
    <xs:sequence>
      <xs:choice maxOccurs="unbounded">
        <xs:element name="Match" type="mce:MatchType"/>
        <xs:element name="Any" type="mce:AnyType"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="confidenceLevel" type="mce:ProbabilityType" use="required"/>
  </xs:complexType>
  <xs:complexType name="IdMatchType">
    <xs:attribute name="idRef" type="xs:string" use="required"/>
  </xs:complexType>
  <xs:complexType name="MatchType">
    <xs:attribute name="idRef" type="xs:string" use="required"/>
    <xs:attribute name="minCount" type="xs:positiveInteger" use="optional"/>
    <xs:attribute name="uniqueResults" type="xs:boolean" use="optional"/>
  </xs:complexType>
  <xs:complexType name="AnyType">
    <xs:sequence>
      <xs:choice maxOccurs="unbounded">
        <xs:element name="Match" type="mce:MatchType"/>
        <xs:element name="Any" type="mce:AnyType"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="minMatches" type="xs:nonNegativeInteger" default="1"/>
    <xs:attribute name="maxMatches" type="xs:nonNegativeInteger" use="optional"/>
  </xs:complexType>
  <xs:simpleType name="ProximityType">
    <xs:union>
      <xs:simpleType>
        <xs:restriction base='xs:string'>
          <xs:enumeration value="unlimited"/>
        </xs:restriction>
      </xs:simpleType>
      <xs:simpleType>
        <xs:restriction base="xs:positiveInteger">
          <xs:minInclusive value="1"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:union>
  </xs:simpleType>
  <xs:simpleType name="ProbabilityType">
    <xs:restriction base="xs:integer">
      <xs:minInclusive value="1"/>
      <xs:maxInclusive value="100"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="WorkloadType">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Exchange"/>
      <xs:enumeration value="Outlook"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="EngineVersionType">
    <xs:restriction base="xs:token">
      <xs:pattern value="^\d{2}\.01?\.\d{3,4}\.\d{1,3}$"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="VersionedRuleType">
    <xs:choice maxOccurs="unbounded">
      <xs:element name="Entity" type="mce:EntityType"/>
      <xs:element name="Affinity" type="mce:AffinityType"/>
    </xs:choice>
    <xs:attribute name="minEngineVersion" type="mce:EngineVersionType" use="required" />
  </xs:complexType>
  <xs:complexType name="VersionedPatternType">
    <xs:sequence>
      <xs:element name="Pattern" type="mce:PatternType" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="minEngineVersion" type="mce:EngineVersionType" use="required" />
  </xs:complexType>
  <xs:complexType name="VersionedEvidenceType">
    <xs:sequence>
      <xs:element name="Evidence" type="mce:EvidenceType" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="minEngineVersion" type="mce:EngineVersionType" use="required" />
  </xs:complexType>
  <xs:simpleType name="FingerprintValueType">
    <xs:restriction base="xs:string">
      <xs:minLength value="2732"/>
      <xs:maxLength value="2732"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="FingerprintType">
    <xs:simpleContent>
      <xs:extension base="mce:FingerprintValueType">
        <xs:attribute name="id" type="xs:token" use="required"/>
        <xs:attribute name="threshold" type="mce:ProbabilityType" use="required"/>
        <xs:attribute name="shingleCount" type="xs:positiveInteger" use="required"/>
        <xs:attribute name="description" type="xs:string" use="optional"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
  <xs:complexType name="RegexType">
    <xs:simpleContent>
      <xs:extension base="xs:string">
        <xs:attribute name="id" type="xs:token" use="required"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
  <xs:complexType name="KeywordType">
    <xs:sequence>
      <xs:element name="Group" type="mce:GroupType" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="id" type="xs:token" use="required"/>
  </xs:complexType>
  <xs:complexType name="GroupType">
    <xs:sequence>
      <xs:choice>
        <xs:element name="Term" type="mce:TermType" maxOccurs="unbounded"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="matchStyle" default="word">
      <xs:simpleType>
        <xs:restriction base="xs:NMTOKEN">
          <xs:enumeration value="word"/>
          <xs:enumeration value="string"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="TermType">
    <xs:simpleContent>
      <xs:extension base="mce:RestrictedTermType">
        <xs:attribute name="caseSensitive" type="xs:boolean" default="false"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
  <xs:complexType name="ExtendedKeywordType">
    <xs:simpleContent>
      <xs:extension base="xs:string">
        <xs:attribute name="id" type="xs:token" use="required"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
  <xs:complexType name="LocalizedStringsType">
    <xs:sequence>
      <xs:element name="Resource" type="mce:ResourceType" maxOccurs="unbounded">
      <xs:key name="UniqueLangCodeUsedInNamePerResource">
        <xs:selector xpath="mce:Name"/>
        <xs:field xpath="@langcode"/>
      </xs:key>
      <xs:key name="UniqueLangCodeUsedInDescriptionPerResource">
        <xs:selector xpath="mce:Description"/>
        <xs:field xpath="@langcode"/>
      </xs:key>
    </xs:element>
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="ResourceType">
    <xs:sequence>
      <xs:element name="Name" type="mce:ResourceNameType" maxOccurs="unbounded"/>
      <xs:element name="Description" type="mce:DescriptionType" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="idRef" type="mce:GuidType" use="required"/>
  </xs:complexType>
  <xs:complexType name="ResourceNameType">
    <xs:simpleContent>
      <xs:extension base="xs:string">
        <xs:attribute name="default" type="xs:boolean" default="false"/>
        <xs:attribute name="langcode" type="mce:LangType" use="required"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
  <xs:complexType name="DescriptionType">
    <xs:simpleContent>
      <xs:extension base="xs:string">
        <xs:attribute name="default" type="xs:boolean" default="false"/>
        <xs:attribute name="langcode" type="mce:LangType" use="required"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
</xs:schema>

Meer informatieMore information