 OK, sem prejdače. Rumi je jaziljno jaziljno, zelo bodo jaziljno na to, da vse prezentacije – tudi tudi tudi tudi sreje spiške ne brzenejo, v NJubole in tudi je bilo listet na vse pomembno, po kjer tega imaš, Andrea, Fabian, Antonio, je zelo po tega priču, teori in prektis. Zelo je bolj prektis, Gotov we all voor geld, in we have a distributed team in italy, belge, me in Chek Republik that the three of us are the core team and each of us lives in a different country. So you can imagine the kind of problems we had with previous versions of Drupal for the Protožeti nje je zgodnji konfiguratičnicoj, bo dreptimo v zgodnji domenju in s gradenjem ili konfiguratičnih, a njih se očilte pomežaj, nači došli tega vsišniti objev, bomo se izvojila u staredu o mistrov, kdaj je to čin glasim poza za držav. Prostožila si travelsi podal tudi objev vsega, zelo odilično nosil doprin co je odelo odlično, kde stajemo pripošlji za obrečenje. Poživamo pomeško z njiž boj, da so je zelo odlipane z kajom konfiguracija, verbec, menšč bito in tenčin duža modlj Voji. Po swordovama, kaj je se vse snog nekaj zelo vse? Poma, ste, da jim nekaj konfiguracija vse zelo vsi nekaj konfiguracija rečenje in njog nekaj vse vse začenje vsi zelo, in can I export configuration changes from development and import them into production? As everybody here probably knows, the answer is, yes, with Drupal8 you can. With previous version of Drupal, it was a bit hekier, but with Drupal8, this use case is completely covered. And so it is a new solution to a very ancient problem that we had in Drupal 6 or 7. And the reference use case, do not forget these two lines, is exporting the configuration changes from development and importing them into production of the same site. We will have to extend it in multiple ways, but configuration management is a tool that was meant for a specific purpose. It is perfect for this specific purpose, but this specific purpose is not the real life. So let's see this specific purpose, our reference use case for configuration management. First, our issue is that we will clone the site to the development environment. OK, you can start from either of the two. You install the site somewhere, be it production or development. In the reference use case it would be production in our real life experience. It's probably development to the one where we actually install it first. And the idea is I install one, I make a full backup with database and files and everything, I clone the production site by restoring the backup. This is already something that will have to be improved, but the reference use case says this. Step two, we just modify configuration. Production site just goes on and we need to develop on it. We make configuration changes. And step three, the live site is still live, of course. And when we are done with development, we export all our configuration changes. We are told what is changed. We commit and we push. Step four, we go online and we pull configuration. We now have a stage configuration that is exactly what we develop. And step five is review changes before applying them to production. So we have rushed comments now that allow to diff our changes. We inspect, we check that everything is expected. And last step, we apply the changes to production and it is as easy as typing why for yes. And this is beautifully covered with Drupal8. We love configuration management for this use case. Only one small note here. The full workflow on the production site would look like something like this actually. I mean, not only configuration, but also running all the database updates first. Actually, this is enforced by an issue that will be committed to core. But still, as long as configuration is concerned, that is all you need to do. Problem solved. Yes for what we wanted to solve. But as I said, real life is really much more complex than this. We want to do more. It's a very nice start, but we want to do more. We want to do stuff in a really clean way. So for example, where we supposed to get rid of database dumps to move configuration to start. And we are now seeing a lot of other scenarios and how they can or cannot be solved by configuration management and by what we have now in core. So the first one is how can I install a site from existing configuration. Meaning I hate the step we had to do that we needed a full database dump. Just because a database dump is inherently dirty, not even if it is the cleanest database dump possible, it's a moment where you lose control. Where for the first time in your development, you would have something that is not based on text file. It's not something that you can inspect. We want everything to always be tracked by text file and something versioned and something that we can really know what is going on. So a database dump means we lose control and how do we solve it. We throw the database dumps away and we use configuration installer. So this is our first tool. Usually running the installer creates a new site. Configuration management has a concept of unique IDs and it wouldn't work properly if we tried to start clean on the production site too. But configuration installer is designed to solve this exact problem. It is an installation profile. Installation profile is one of the first screens in the Drupal installation. You select either minimal or standard or anything else and in this case you would select config installer and it takes over the Drupal installer and it allows sites to be creating from an existing configuration. So typically we will see how it changes in practice but you will have a configuration you want to clone. You just clone configuration. You do not replicate the database because the database has things that are not under control. It is an installation profile. You place it in the profiles folder and it is such a good tool that it should be on every site and possibly in core but we are going to say more about this. If you are not familiar with the user interface of configuration installer this is simply where it plugs in and once you have selected configuration installer as your profile you get a new screen here to import existing configuration. So the typical workflow will look like I am the developer, I exported my configuration it is in git and the production site is not clone database wise but by importing the full configuration I exported from my development machine. What about having it in core? There is an issue for that and there is a sprint about this so we might see it done or considered doable by this Drupal con already. We might finally have Drupal core sites that can start from an existing configuration and solve this third issue we identified. Next step and next problem. For questions we are grouping all questions after the session so just please be patient and when we are done we will have some minutes for all questions. Can I override the local configuration? Meaning I am a developer, I have this wonderful tool but it starts to feel like a problem having a tool that really exports the whole configuration and this means that if I want to customize my development configuration in ways that I do not want to get exported in production. For example, I have different API keys in my local machine and in production or I want verbose or logging enabled in my local machine but turned off in production. If I do things the normal way by saving forms then I am effectively altering configuration and these small changes would be exported and picked up on production and this is something that I do not want. Fortunately we are covered for this use case by the concept of overriding. Overriding is just meant to give us the way to apply these local changes on our development environment even though it is not covered by the reference use case it is covered by the standard Drupal core tool that is the config array and here is how it works. With the config array you have run time overriding in code, configuration is still there but it gets overridden so what you see is not what is in configuration. The typical example is to add the line to settings.php or like the documentation advocates for settings.local.php file that you include from settings.php in your development environment and here you just define values for this array that will override whatever the configuration says. So for example to enable verbose or logging in development only you write this line of code. How does it work for editing? Editing Drupal is very smart. If you open a form that would modify overridden configuration you do not see your overridden value because Drupal prevents you from saving it by mistake. Drupal knows that this configuration value was not set in configuration but was overridden by you in code in the settings.php file and it will show to you the old version, the original non-overridden setting. This means that whatever stupid things I do with config is really local to my environment. If I edit a form and save it overridden values will not be there. It's very smart if you think about it. And same of course will happen for exporting. When you export these overrides they are not exported. So this is exactly what we want from this tool. Local configuration that stays local overrides the full configuration locally. If you are curious on how Drupal managed to do this well if you delve into code you will find that whenever configuration is retrieved it can be retrieved as mutable or immutable as Drupal calls it. When we are retrieving for read-only mode like the real configuration you have or the display of configuration it's immutable if it is read-only. So overrides are considered because it would be harmless to display them. This is why you can override with config and have the displayed site name in the header being the overridden value. Since you are reading it and when reading it is safe to include overrides. In the other scenario when you want to set or export values overrides must be ignored and Drupal has special ways to get configuration in this case and it is the mutable configuration and it is used when configuration is retrieved in read-write mode something that I will want to retrieve then modify and save. This is the trick that Drupal uses to be clean with overrides. There is only one small issue left but fortunately this is quite easy to address how do I actually find the keys and values to put in config. Well, you do it in the form first you export configuration and you inspect the diff. So the first time you really check the changes locally then you will throw them away. You see what configuration file changed you see what properties changed by really looking at the YAML file and from here you get system.logging and system.logging will be the first key here error level and error level will be the second key here and the value verbose then you trash the real configuration change and you only keep your code copy. Is this satisfactory? Yes, but again you can only alter existing configuration meaning that you cannot add new configuration this way you cannot completely unset existing configuration either and there are things that still you cannot do this way like you cannot override in the typical use case I want to develop module in my local machine not in production I will not be covered here and there are also a few quirks that you cannot really override some small things like the color of Bartik and other things that are coded in non-standards way so to say so it's they cannot be overridden this way for technical reasons but if we need more tools and I let Fabian talk about the other use cases Yes, so so the next step is to exclude modules from getting into the production deployment workflow and often we have this case that we want to have development modules on our site and then not export them there are several options the first one is with Drush Drush has a flag that you can set called skip modules and you can give it a list of modules that you want to ignore but at the moment Drush still exports the configuration that depends on these modules so when you do that you also have to ignore the configuration that comes with modules otherwise the configuration that you export results in a invalid state because you have configuration that depends on modules that are not installed and the Drupal will not import the configuration again so you have to inspect it manually to make sure that your export is still in a consistent state there is a second method that previous next recently blocked about they add the concept of ignore list which is a YAML file where you list all the configuration that you would like Drush to ignore when exporting it works in a similar way as the native Drush command and the third method is a new module called configuration split and their configuration overrides are not at runtime but at import export time so the configuration that you have active in on your local site is the one that you want to have so on your local site you have the development modules enabled and you have the configuration for those modules but when you export it you split them off and the split is a configuration in itself so a part of this configuration is which folder the split will be exported to you can have a black list of configuration in addition to the ones that are detected from the modules that you want to split off for example in the well you also want to remove the development menu item which does not explicitly depend on the development module and you can have a set of configuration that is ignored when importing and exporting so it's when the black list configuration when you export it, it gets removed from the sync directory where the normal export would go to and the ignored one will leave the one that is already here and export the setting to the folder and of course the configuration, their entities themselves so their configuration themselves so you can override them with the config override method there is a drash commands for that that essentially replace the config export and config import drash command and also there is a Drupal console command to do the same so this is the current UI for this split configuration it's much nicer with also chosen and at the bottom there would be also the wait so you can have several splits and wait them so that they happen in the correct order the next big chapter is how to work in parallel with the colleague we've seen this configuration export and configuration import but how does it work if two people work at the same time the problem is that when you export configuration you remove all the configuration that is in the export directory and when you import the configuration you remove everything that is in your local active configuration storage but luckily there is a git so if you work with git and you let git handle the merging then you're mostly on the safe side so in this case we consider two instances of the same site multiple we don't cover it right here but it's essentially the same it works for as many copies as you want and git just merges and you have to then just import the configuration again text files are perfect for git so it was also designed with git as in mind so the way this works is you share git repository for both code and configuration you install the site from the initial configuration as Andrea explained before and you adopt the successful git branching model the project bootstrap is very similar the first developer that starts the project installs it with the installer and exports the configuration and commits it to git every other subsequent developer and the production just clone the code and install it with the configuration install the profile and then go from there so the parallel development we work with the git branches and commit and push the configuration changes to the branch in parallel but careless merging can be dangerous and maybe problematic remember that git does not care about Drupal at all, git is completely independent from Drupal but the configuration is very important to Drupal so you need to let git do the merging and let Drupal decide whether the merge was successful or not if you do not follow the good workflow then you may lose uncommitted work you may accidentally overwrite work of other developers and configuration could look okay at first but actually is not valid for Drupal so the safe sequence is exporting configuration committing it other people's configurations importing the configuration and pushing to the other developers let's look at a couple of cases what happens when you don't respect this order for example, if you import before you export it then you delete all your work all the things you did since the previous time and there is no backup so tough luck when you merge before exporting the export deletes the previous work and replaces it by what you have in your site so you basically ignore what your colleagues have done and you can recover this because git can handle that it's just not the straightforward workflow but with some git foo you can recover from this if you merge before commit then you will have the unstaged files and you merge and then maybe you get in trouble when there is a merge conflict and it's not as easy as just reverting to the commit that you knew worked because merge conflicts obviously cannot be imported as such and if you forget to import it after you merged then you will keep the state of your Drupal site the way you had it before you did the merge and you continue developing and then the next time you export it you're in the same situation as before and you may have more difficulties then to solve what should be merged and how it should work if we look at the nice example how you can break the configuration with git you're all familiar with the standard installation profile so you installed that the first developer on his branch deletes the tags from the article content type that results in two changes and two files are removed the field instance and the field storage because the tags was only used on the article content type and when you remove the last field it also removes the storage the developer B adds a tags the tags field reuses the field for the basic page which results in adding the field instance for the basic page so this work happened in completely different files so git is very happy to merge this but the resulting merged configuration is invalid because now you have the field instance for the tags on the basic page without the field storage and it will just not work so the takeaway from this is that when merging the configuration always check that it's still valid by importing it and at this point you can also then fix it relatively easily of course this is an example of very basic of course you don't do it exactly this way but when you're working on a larger project things that are more complicated than this but have the same effects can also happen ok so now we're going to have a look at another use case what about package configuration and reuse it this was actually what we all used in Drupal 7 we had features that was covering both use cases so it would cover the deployment use case because it would package your configuration features and deploy it and then have it on production but then it would also cover the usage use case so in Drupal 8 configuration management works a little bit differently as you've seen so far basically the configuration in Drupal 8 is monolithic so you have one configuration that covers the whole site you don't have configuration package into module so what features for Drupal 8 does is basically a configuration package so it's really stop acting as a deployer let's say if you want and it became only what was best at it so a package of configuration it's entirely new for Drupal 8 and it takes advantage of configuration management of course because in Drupal 8 modules can have configuration already if a module has configuration in the install directory can install configuration once the module is enabled and basically what feature does it reuses this this technology that is already there what feature offer then since the configuration it's all taken care by core it offers an automatic packaging and this is really what feature is best of so what feature does basically analyzes your site and detects way of slicing your site into features and so then it can propose to you basically the different ways that you can featureize your current site and package configuration and reuse maybe one module of your site on another site so basically features for Drupal 8 only focus on reusage and it is a development module it means that the features model any more like it was with Drupal 7 so it is really like deval ish should actually never even commit the features model itself to production it's just a development module like deval is so it's just packages and that's it and it's job is done the resulting features as we said already are just modules so they just come with configuration you enable the module so the feature Drupal core will take care of taking configuration from the install directory contained into the module and staging it to your site from that moment on you will treat that configuration as part of your monolithic Drupal 8 core configuration so when you develop over this site you will just export all the configuration as we have seen so far and just continue with the normal workflow so it is just about features that are really usable for reusage and to bootstrap basically so yeah, how feature works so let's see quick example on how to use feature so you enable feature module then you also enable feature UI module and then you visit the setting page where you basically have depending on the like slicer that you enable you can have different features proposed to you for example you can have features proposed to you by content type so everything that belongs related to content type is packaged into features and proposed to you like a blog feature for example or you can have namespacing slices so you can say slice my site per namespace all configuration that is prefixed with this namespace should belong to a feature so by configuring this setting basically features can propose to you already packaged module then what you do is just check that box and then download it and then you have your configuration basically ready to be reused on another site so the takeaway message of features for duplicate it's really the following I mean if you are using features for deployment you are really doing it wrong it's not this main use case you could do that but it's a bit of a headache I mean configuration management really really works well for that so there is no reason to find other solutions for that it's to reuse partial configuration across sites so you are not going to store all your site into a feature and then use it in another site making the other site it's just a way to package bits of configuration for your site for example the blog feature and then it's only a development module this time so all the modules that you create with features do not depend from features so you don't need to have it around on production which is very very good news so it's feature perfect because it looks perfect so far but there are actually some shades because the way configuration management is it does not really allow full packaging at least not for every kind of configuration for example well the first thing overrides are not supported properly so updating a custom distribution for example if you have a distribution that uses features and you you enable a feature like a blog feature from that moment on that configuration into the blog feature is part of your configuration workflow normally what happens if there is a new version of that of the blog feature itself that has different configuration so feature does not provide you with the clean path to do that so the updates the blog feature will need to provide custom update hooks in order to tweak the configuration changes etc well menu links are not exportable but that's by design because menu links are content entities there are modes to go around that but yeah that's also what feature does not provide as opposed to the version in Drupal 7 and then last but not least permissions are not exportable so and they are currently removed why because at the moment permissions in Drupal 8 are part of information attached to the role configuration object basically so you cannot abstract permission from a role that is attached to and that's again Drupal 8 by design so we don't have anywhere going around that so let's say feature is perfect as far as it can go and for these three like gaps let's say there is actually documentation page actually I must say the features for Drupal 8 documentation is really really well written you find all the answers to your questions there and you can have a look to the gaps there are links to issues so if you are interested you can have a look at that ok so now it's here is another problem so everything looks pretty pretty nice now our life is much much easier as developers we have answers for most of our problems that we had in Drupal 7 so it's really an ideal situation so far but we still have this this did not go away in Drupal 8 so what happen if a client starts to mess up with configuration on production right this is actually different because imagine the ideal situation so you have like all your configuration is correctly exported it's version is deployed and your development team is great works great together and adopts a solid git branching model so it takes care of having a branch per feature and storing the configuration but once the configuration is deployed on production then the client starts to fiddle with your configuration and changes stuff so what happened then so the problem here is that changing configuration is an act of development in Drupal 8 anywhere because since configuration is monolithic any form submitted you do on the administration page is a changing configuration meaning that that's a tall effect development so your client is actually a development that you cannot a developer that you cannot control that you will never be able to control in a way around that there are different options this is the most radical one the one I love the most because it really solves the problem I mean it's an actual solution to the problem which means you can just lock the configuration production and there is no way even with user 1 that you can actually submit a form ever again of course this is not a configuration it's not exportable it's just a setting that you add to your setting PHP on the production environment specific setting and this basically locks the configuration production is very nice until the client complains of course the second one it's a bit more elaborate but this will allow the client to do more or less whatever he wants but then you need to have a person that is responsible for following that following what's happening so if we can say the bad side of having a monolithic configuration is that everything is struct because since everything is struct then everything is traceable so whatever the client does you can be sure that you know about it how by exporting the configuration from production and then diffing it with the one you have in development because then you know what changed before in Drupal 7 for example you didn't know what changed that was also bad because that happened also in Drupal 7 so what you would do you would have different branch if you want you would have like dump the configuration from production on this branch and then work the git work your way out with git so you could like compare these three different branches and then decide what to do with that call the client etc once everything is set up you just commit merge the two run again as continuous integration maybe fix some test if something important changed etc and once it's done you basically restore the production site to a sanity level again and then that's it the third option is again configurational split that's actually a module that Fabian is working on it's so the way that configurational split works is that you can actually configure which configuration entity goes where in which directory so you have like now one sync directory where all our configuration is but if you use configuration split you can say I want this, this and that configuration entity to go to another directory when I export so you can really split them this is pretty powerful because you can work your way around that problem with the client in many different ways for example imagine that that client changed your configuration online then you go and review the changes say I want this configuration entity that my client worked on for example review, I don't want them to be part of my development thing because they will break my test that I don't care and this is not really what this site is about but I still want the client to have it because this work let's say so what you do you take this configuration entities you create configuration split entities saying that this tree goes to this directory aside we call it for example config client so that configuration stays there it will never bleed into the sync directory that is what the developer share that is what the continuous integration uses to run tests etc etc what you do then you export using config split export command to that directory this will read the configuration you have in your site and will do the right thing you pull the new configuration of business users so you just get pull and the sync directory gets a new configuration etc and then you import configuration on production the config split import which will merge the directory and then have it in production this will allow for the team to always have the same configuration under control and then have extra views extra content type that you really don't want to have around as developer just on this directory there in the config client without bothering so alright so the last problem that we are going to face today so can I deploy content that my configuration depends on so this is a very old problem imagine a view that is filtered by taxonometer how many times we had that so you export the view in feature but then there is like t5 and then when you put that view on production t5 is another term it's not our t5 so it's a mess so well that's basically the problem so the plan configuration it depends on nodes blocks, taxonomy terms whatever else the problem is that the content is not really exported along with configuration but Drupality got much much better in that too because first of all content has uuid everywhere so all content entities come with uuid so they are actually unique I mean node will always have nid in like 1, 2, 3 but the actual id is uuid of that node and that goes for all content entities it's really common then the first thing that Drupal does, this does by default so when you import configuration he will check for content dependencies on configuration and then if those content entities are missing he will fire an import missing content event this does under the hood actually you can always write event subscriber and handle that event and do whatever you need to do or if then you get the entity with this uuid then you might have that entity exported somewhere and then you might just put that entity back and then fix the thing if nothing happened then there is the final missing content subscriber is the only event subscriber that actually handles that event is provided by Drupal core and what that handler does is simply removes at runtime those dependencies content dependencies from that configuration so that the configuration can be imported it does not alter the configuration it does not change the configuration so it's not saved without the dependencies the dependencies are still there it's just a runtime removal so this is option 1 option 2 you can use a very nice model called default content so basically this default content takes advantage of all the effort that went into the Drupal headless initiative so now we can export entities using the HAL plus JSON format and they can take care Drupal core takes care about resolving the entity references so if you export a node you get also the author of the node the taxonomy terms that are linked to the node and all the rest that's all out of the box so basically how the default content works is that if you have a module with the slash content directory with the entity type so that's that format there and you store your JSON you have a supported entity in JSON using different ways the most convenient is using the trash command that comes with the module of course but you could also not use that you could also fabricate your own way of exporting entities if you want then once that module is enabled then you get these entities imported the next step that is also an issue for that is to actually not be bound to the event that the module is enabled or is installed in order to have the entities imported you can do that as well, it's very easy you can extend the service that this module provides and make your own custom service that does the trick so you can export to a custom directory commit your content with your code and with your configuration all together your default content and then part of your build will be also to import the default content so then this is actually a layout of what you get when you use the default content module so that's our default content dump that we have for one of our projects that's not really the same directory structure because the default content module does not have the bundle names under the entity type so that's what we did, it's very easy to do that so you can format this and there you can see also how it looks so it's just a JSON file that's the UUID your best friend in this case language code title and all the fields plus references it's all bundled together so that's option two option three of course is to use deploy but then you get really serious about that I mean if you really need a complete content deployment solution environment so it's not as lightweight as the other but you actually basically everything is the real actual solution to the actual problem the last thing I mean you can also Drupal8 is also next to the hook updates that we are all very familiar with as DrupalDeveloper in Drupal7 you also have another hook which is meant for you to work with content manipulation and that's hook is called post update it is not a hook that has a number after it so it does not work like the hook update it does not have 8001, 8002 because it's not meant to be run sequentially this is a one off operation that you do to fix your content when you know what you are doing when you are fixing and you know the state of the site that you are fixing it's really meant for this so if your configuration blocks something you know that your production site has that state you build, you do this you implement this, your fix is in this this is executed only once after the hook updates are run only that one time and that's it it's very useful when you have modules in unstable state that will change still the schema for example Drupal8 is quite common now still and then this will basically fix fix your content alright so that's the basically the overview of what we what we have seen we can go ahead so that's basically the overview we are giving a star that's not of course saying one is worse but it's more like a completion to have an idea of what's the level of completion of all these problems that we have planned so can I deploy configuration yes we can for sure can I install a site in configuration yes but there are still some quirks it's still not in core so it doesn't take 5 stars but it's gonna be in core this weekend for sure so it's gonna be there still a lot of work all of you help maybe look how many people so can I write local configuration yes we can too but still there are some little issues there as well so it's not 100% perfect like the deployment can I exclude modules from getting deployed well I can but then I have this problem with configuration that I need to exclude ignore we have several solutions to do that so it's still not really ideal it's not established much so it gets 4 stars can I work in parallel with my colleagues absolutely yes in a very very well way so can I patch configuration use it we can really that's not trip advisor 3 3 is good I mean it's a good 3 stars are not 1 or 0 3 stars but we can package configuration and Fischer does very well, very good job about that but yeah the core has some limitation and we have to go around that once we do it we contribute then we get 5 stars there too well can I handle a client messing with production configuration that would have taken 2 stars but thanks to the read-only module tech took 4 because that's really actually a solution to do the read-only module so yes you can prevent this and maybe work your way around it configuration speed is also a good initiative towards that and then can I develop my content again for star we can do that the actual solution is pretty big so like deploy and not everybody has the capability of maintaining that so it takes 2 for star because you still need a bit waves around that that's it so I give you another word Fabian for a list it's just a list of projects most of them we touched in this presentation the config installer again very useful to install from an existing configuration configure it only to not let clients mess with configuration on the life site config update reports changes between the original and active configuration of a module this is placed into the features use case features actually depends on this config develop is a module that helps with developing configuration has a number of things it does config split we covered in this talk config tools allows you to automatically commit configuration changes to a git repository and also of course automatically exporting them when you submit the form before committing it features we covered and the configuration sync which is a way to synchronize back the configuration that comes the original configuration that comes with the module into the active store so it dissolves a bit the problem when you have a module and it comes with configuration this configuration when you install the module gets into the site configuration and then is ignored from then on so the profiles and distributions update will use something like that there is a couple more that and also newer ones that we didn't list but there is many people working in this space thank you very much rate the session and the questions are in the microphone they ask that everybody who is making question please use the microphone theirs because they are getting recorded is it possible to use when you use config split to use different splits together and only one of those splits for instance can you have a config split for your client config and a config split for your development config without importing them both so you can have different splits they can be ordered so that they are split or they are applied in a certain order and from the drash command you can also select which split to include when importing the configuration ok cool thank you about features if I understand it correctly when you enable the feature it imports the configuration should you just disable the feature after that because all the configuration is saved to the database and you can export it as a bulk it depends it depends because often features is a module so you can also provide logic that comes with it so often you don't only want to have it as a repository for the default configuration but you also want it to do something with it and also since this module the configuration will depend from the module which is the feature not in the features not ok so for droplet features is kind of just a packaging solutions for your module and you can also collect your configuration into the module regarding your take away when merging check that the configuration is still valid by importing it that doesn't work always imagine two people working on two separate branches on form displays for instance and adding a new entity reference field which almost looks the same after merging branch A and then merging branch B you will have a merge which will override the first merge of branch A basically because it thinks that this is the same item it's working on has the same weight and also imports fine because it's not a broken configuration it just works but you are actually missing features yes exactly and that's why we recommend that's why we say check it you have to you merge it and then you let Drupal decide whether it's good or not and of course if Drupal is successful in importing it you still have to make sure that it's actually correct and for that we recommend of course automated tests that check that the functionality still works is it possible with config overrides to have permissions overwrite like one myonimus users see the devil information yes a configuration can be overwritten you overwrite in that case the role and you can overwrite it as well in that case you overwrite the role and then we just change the permission of that role but you have to overwrite the old role the file is the role the one we seen in our example so you would have this first key the role the permission ok, thank you I have a question related to writing integration test like how do you manage the configuration when writing a Drupal web test case, like creating the fields and all the structures required to access the pages so for tests we use two different kind of tests the unit testing for the glasses and then be hot actually for the site and for that we rely on the fact that our sites will install cleanly so there is a continuous integration environment that will install the sites and then run the test on top so we use that one and that does not we don't care about the database dump or the state of the database because we just use be hot but the actual yaml files with the fields and the base fields how do you that's all including the configuration in the site as well so we push the configuration together with all the site, the site installs using configuration installer using that configuration so we recreate basically a clean starting point including also content so if we need content we also import default content like we have seen so basically after the first install all the site is really in a clean state and on that state that we can assume basically we run all our be hot test be able test with be hot we don't have any other methods for that and then next to that we have unit testing for the classes in the object services themselves but that's another thing that also runs on continuous integration but it does not test the site behavior test the site code which is a different kind of domain I have a few questions first of all configuration installer profile can you automate things so that you can import them deployment on Jenkins drum yes, you can run it with Drush site install as a parameter so no problem you can automate it as much as you wish the important part is that you set the config directory before you run the installer in the settings.bit but the second one is related to features you said that it's a development module and you shouldn't install it on production but then if you have a module that is already installed then you modify the configuration how do you import the changes into the production because with features you have features revert but if you don't have it on production anymore then you cannot revert the configuration to the new changes so you share the when you share the features or when you enable the feature you do that on the development side you revert the feature and the revert becomes part of the site configuration that you then deploy for example, I had a use case when a module was implemented you had a configuration that was deployed already to production this was a feature and you locally changed it and then you deploy the configuration to production but then you cannot revert that configuration but import configuration import if at that point you are on hookup date or on Drupal's native configuration management the idea is not to use it as a deployment tool any longer this is the direction they have taken so you actually cannot use features to all the things the config sync and the config update detect this whether you do that so you have to be clear whether where the place where you develop the feature or the site where you use the feature and the site where you use the feature you can have features enabled on the development instance of that site and on the production instance you don't revert the feature because you deploy the configuration that you revert it on the development side and one last question if you have a configuration that you want for the administrator to allow to change for example Facebook URL that you want for him to set up but when you import the configuration you don't want to be overridden by your import and also you don't want it to be put in repository because it's something that you want to be omitted so how do you treat this case? in that case you would use the configuration split to a directory that is outside of the git repository and as a general question it seems features is more of a combination now between configuration split and configuration sync modules so which is the case that you are using? not really, they try to solve different use cases configuration split is really import time override of configuration and features is packaging configuration for reusing on other projects like it helps you packaging and it does it also providing automatic slices so it's really a different use case so it still makes sense to use features okay, thanks thank you okay okay time but okay thank you