https://media.ccc.de/c/osc18 This feed contains all events from osc18 as mp4 see video outro Thu, 23 Jan 2025 18:42:04 -0000 https://static.media.ccc.de/media/events/osc/2018/osc18_logo.png https://media.ccc.de/c/osc18 https://media.ccc.de/v/1939-annual-discussion-with-opensuse-board The openSUSE Board (Richard Brown, Gertjan Lettink, Christian Boltz, Sarah Julia Kriesch, Ana María Martínez Gómez and Simon Lees) will present the outcome of their last F2F meeting, where they started driving its collective agenda for the next year. After that, everybody is welcome to ask questions, give feedback, make suggestions and present ideas. The openSUSE Board (Richard Brown, Gertjan Lettink, Christian Boltz, Sarah Julia Kriesch, Ana María Martínez Gómez and Simon Lees) will present the outcome of their last F2F meeting, where they started driving its collective agenda for the next year. After that, everybody is welcome to ask questions, give feedback, make suggestions and present ideas. about this event: https://c3voc.de Sun, 27 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1939-eng-Annual_Discussion_with_openSUSE_Board_hd.mp4?1527433925 9eah1LaL9DZcns3GraeyEw 2018-05-27T00:00:00+02:00 Douglas DeMaio No osc18, 1939 The openSUSE Board (Richard Brown, Gertjan Lettink, Christian Boltz, Sarah Julia Kriesch, Ana María Martínez Gómez and Simon Lees) will present the outcome of their last F2F meeting, where they started driving its collective agenda for the next year. After that, everybody is welcome to ask questions, give feedback, make suggestions and present ideas. The openSUSE Board (Richard Brown, Gertjan Lettink, Christian Boltz, Sarah Julia Kriesch, Ana María Martínez Gómez and Simon Lees) will present the outcome of their last F2F meeting, where they started driving its collective agenda for the next year. After that, everybody is welcome to ask questions, give feedback, make suggestions and present ideas. about this event: https://c3voc.de 00:51:50 https://media.ccc.de/v/1768-developing-sle-factory-and-leap-distributions-at-the-same-time-impossible Starting with openSUSE Leap 42.2, a lot of cooperation has been done to bridge gaps between openSUSE and SUSE Linux Enterprise distributions. Things have been improving nicely with openSUSE Leap 42.3. We'll go into details on what this cooperation means for both openSUSE contributors and for SUSE and how we ensure it takes place. We will also discuss how we adjusted SLE15 development and how was done in harmony with openSUSE Tumbleweed (rolling release). Starting with openSUSE Leap 42.2, a lot of cooperation has been done to bridge gaps between openSUSE and SUSE Linux Enterprise distributions. Things have been improving nicely with openSUSE Leap 42.3. We'll go into details on what this cooperation means for both openSUSE contributors and for SUSE and how we ensure it takes place. We will also discuss how we adjusted SLE15 development and how was done in harmony with openSUSE Tumbleweed (rolling release). about this event: https://c3voc.de Sun, 27 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1768-eng-Developing_SLE_Factory_and_Leap_distributions_at_the_same_time_impossible_hd.mp4?1527429647 cb4WPl8YMJeHGRt-929MBQ 2018-05-27T00:00:00+02:00 Frederic Crozat No osc18, 1768, openSUSE Starting with openSUSE Leap 42.2, a lot of cooperation has been done to bridge gaps between openSUSE and SUSE Linux Enterprise distributions. Things have been improving nicely with openSUSE Leap 42.3. We'll go into details on what this cooperation means for both openSUSE contributors and for SUSE and how we ensure it takes place. We will also discuss how we adjusted SLE15 development and how was done in harmony with openSUSE Tumbleweed (rolling release). Starting with openSUSE Leap 42.2, a lot of cooperation has been done to bridge gaps between openSUSE and SUSE Linux Enterprise distributions. Things have been improving nicely with openSUSE Leap 42.3. We'll go into details on what this cooperation means for both openSUSE contributors and for SUSE and how we ensure it takes place. We will also discuss how we adjusted SLE15 development and how was done in harmony with openSUSE Tumbleweed (rolling release). about this event: https://c3voc.de 00:44:25 https://media.ccc.de/v/1840-behind-the-scenes-of-the-obs-team If you ever wondered how the OBS gets developed, this talk will provide some insights into how the OBS development works including tools we use (e.g. depfu, hakiri, codecov) and workflows we follow (e.g. Scrum). OBS developers have also changed a lot in the last time. The OBS frontend team has doubled its size within the last 2 years. We will explain how we brought everyone up to speed with techniques and methodologies such as Scrum and mob / pair programming. The reference installation build.opensuse.org is now also OBS frontend team responsibility. We changed the deployment process by introducing a demolition squad role. Beside build.opensuse.org, we also release OBS regularly and are in charge of quality assurance using e.g. openQA and Kanku. Last but not least, we will cover how you can participate in OBS development, both as a developer and suggesting changes and features. If you ever wondered how the OBS gets developed, this talk will provide some insights into how the OBS development works including tools we use (e.g. depfu, hakiri, codecov) and workflows we follow (e.g. Scrum). OBS developers have also changed a lot in the last time. The OBS frontend team has doubled its size within the last 2 years. We will explain how we brought everyone up to speed with techniques and methodologies such as Scrum and mob / pair programming. The reference installation build.opensuse.org is now also OBS frontend team responsibility. We changed the deployment process by introducing a demolition squad role. Beside build.opensuse.org, we also release OBS regularly and are in charge of quality assurance using e.g. openQA and Kanku. Last but not least, we will cover how you can participate in OBS development, both as a developer and suggesting changes and features. about this event: https://c3voc.de Sun, 27 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1840-eng-Behind_the_scenes_of_the_OBS_team_hd.mp4?1527425085 XUmvj7bmV7AMyqV3kruQtQ 2018-05-27T00:00:00+02:00 Christian Bruckmayer No osc18, 1840, openSUSE Tools, processes and procedures used by the OBS team If you ever wondered how the OBS gets developed, this talk will provide some insights into how the OBS development works including tools we use (e.g. depfu, hakiri, codecov) and workflows we follow (e.g. Scrum). OBS developers have also changed a lot in the last time. The OBS frontend team has doubled its size within the last 2 years. We will explain how we brought everyone up to speed with techniques and methodologies such as Scrum and mob / pair programming. The reference installation build.opensuse.org is now also OBS frontend team responsibility. We changed the deployment process by introducing a demolition squad role. Beside build.opensuse.org, we also release OBS regularly and are in charge of quality assurance using e.g. openQA and Kanku. Last but not least, we will cover how you can participate in OBS development, both as a developer and suggesting changes and features. If you ever wondered how the OBS gets developed, this talk will provide some insights into how the OBS development works including tools we use (e.g. depfu, hakiri, codecov) and workflows we follow (e.g. Scrum). OBS developers have also changed a lot in the last time. The OBS frontend team has doubled its size within the last 2 years. We will explain how we brought everyone up to speed with techniques and methodologies such as Scrum and mob / pair programming. The reference installation build.opensuse.org is now also OBS frontend team responsibility. We changed the deployment process by introducing a demolition squad role. Beside build.opensuse.org, we also release OBS regularly and are in charge of quality assurance using e.g. openQA and Kanku. Last but not least, we will cover how you can participate in OBS development, both as a developer and suggesting changes and features. about this event: https://c3voc.de 00:28:46 https://media.ccc.de/v/1756-kanku-bridging-the-gap-between-obs-and-developers kanku is designed to give you a better integration of your kiwi images built in Open Build Service (OBS) into your development and testing workflow. It provides a framework for simple automation of complex setups, e.g. to prepare your development environment or run simple tests. This talk will give an overview of the motivation/goals and basic concepts/architecture of kanku. Links: * Presentation - https://m0ses.github.io/kanku-presentation/overview.html#/cover-page * Github Pages - https://m0ses.github.io/kanku/ * Github Code - https://github.com/M0ses/kanku/ kanku is designed to give you a better integration of your kiwi images built in Open Build Service (OBS) into your development and testing workflow. It provides a framework for simple automation of complex setups, e.g. to prepare your development environment or run simple tests. This talk will give an overview of the motivation/goals and basic concepts/architecture of kanku. Links: * Presentation - https://m0ses.github.io/kanku-presentation/overview.html#/cover-page * Github Pages - https://m0ses.github.io/kanku/ * Github Code - https://github.com/M0ses/kanku/ about this event: https://c3voc.de Sun, 27 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1756-eng-kanku_-_Bridging_the_gap_between_OBS_and_developers_hd.mp4?1527424061 MZKD8dcnm43KTqd1aQ7VYw 2018-05-27T00:00:00+02:00 Frank Schreiner No osc18, 1756, Open Source A convenient way to work with your OBS built images kanku is designed to give you a better integration of your kiwi images built in Open Build Service (OBS) into your development and testing workflow. It provides a framework for simple automation of complex setups, e.g. to prepare your development environment or run simple tests. This talk will give an overview of the motivation/goals and basic concepts/architecture of kanku. Links: * Presentation - https://m0ses.github.io/kanku-presentation/overview.html#/cover-page * Github Pages - https://m0ses.github.io/kanku/ * Github Code - https://github.com/M0ses/kanku/ kanku is designed to give you a better integration of your kiwi images built in Open Build Service (OBS) into your development and testing workflow. It provides a framework for simple automation of complex setups, e.g. to prepare your development environment or run simple tests. This talk will give an overview of the motivation/goals and basic concepts/architecture of kanku. Links: * Presentation - https://m0ses.github.io/kanku-presentation/overview.html#/cover-page * Github Pages - https://m0ses.github.io/kanku/ * Github Code - https://github.com/M0ses/kanku/ about this event: https://c3voc.de 00:17:34 https://media.ccc.de/v/1711-making-open-source-routers At CZ.NIC, we are making open source routers. Those come with automatic updates, plenty of software available in repositories, root ssh account and other nice features. What challenges does it bring? How do we cope with them? Why would you want open source router anyway? What open source project are we building on top? And what actually spinned off out of our router? At CZ.NIC, we are making open source routers. Those come with automatic updates, plenty of software available in repositories, root ssh account and other nice features. What challenges does it bring? How do we cope with them? Why would you want open source router anyway? What open source project are we building on top? And what actually spinned off out of our router? about this event: https://c3voc.de Sun, 27 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1711-eng-Making_open_source_routers_hd.mp4?1527424040 yZCj2cAxcaB9BsQRm7YYRg 2018-05-27T00:00:00+02:00 Michal Hrušecký No osc18, 1711, Embedded Systems At CZ.NIC, we are making open source routers. Those come with automatic updates, plenty of software available in repositories, root ssh account and other nice features. What challenges does it bring? How do we cope with them? Why would you want open source router anyway? What open source project are we building on top? And what actually spinned off out of our router? At CZ.NIC, we are making open source routers. Those come with automatic updates, plenty of software available in repositories, root ssh account and other nice features. What challenges does it bring? How do we cope with them? Why would you want open source router anyway? What open source project are we building on top? And what actually spinned off out of our router? about this event: https://c3voc.de 00:54:29 https://media.ccc.de/v/1960-your-first-steps-with-opensuse-kubic Curious about openSUSE Kubic and using it for running your containers workloads ? I will introduce the various way to deploy openSUSE Kubic and explain how to get started with systems operations and containers management. From scratch to fully running containers in 45 minutes :) Curious about openSUSE Kubic and using it for running your containers workloads ? I will introduce the various way to deploy openSUSE Kubic and explain how to get started with systems operations and containers management. From scratch to fully running containers in 45 minutes :) about this event: https://c3voc.de Sun, 27 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1960-eng-Your_first_steps_with_openSUSE_Kubic_hd.mp4?1527422114 IUdAE50KJLb6eQc1SPP9Rg 2018-05-27T00:00:00+02:00 Paul Gonin No osc18, 1960, Cloud and Containers Practical information on how to get started with openSUSE Kubic to host your containers Curious about openSUSE Kubic and using it for running your containers workloads ? I will introduce the various way to deploy openSUSE Kubic and explain how to get started with systems operations and containers management. From scratch to fully running containers in 45 minutes :) Curious about openSUSE Kubic and using it for running your containers workloads ? I will introduce the various way to deploy openSUSE Kubic and explain how to get started with systems operations and containers management. From scratch to fully running containers in 45 minutes :) about this event: https://c3voc.de 00:41:12 https://media.ccc.de/v/1858-fantastic-arm-boards-and-how-to-use-them Following up on last year's talk (https://events.opensuse.org/conference/oSC17/program/proposal/1246) I intend to give an update on hardware support in openSUSE and software support for new boards. This will include an update on Meltdown/Spectre mitigations and what users need to take care of. Following up on last year's talk (https://events.opensuse.org/conference/oSC17/program/proposal/1246) I intend to give an update on hardware support in openSUSE and software support for new boards. This will include an update on Meltdown/Spectre mitigations and what users need to take care of. about this event: https://c3voc.de Sun, 27 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1858-eng-Fantastic_Arm_boards_and_how_to_use_them_hd.mp4?1527417289 FCDA2jM81L7uJcD1iXje6A 2018-05-27T00:00:00+02:00 Andreas Färber No osc18, 1858, Embedded Systems News on hardware and Spectre Following up on last year's talk (https://events.opensuse.org/conference/oSC17/program/proposal/1246) I intend to give an update on hardware support in openSUSE and software support for new boards. This will include an update on Meltdown/Spectre mitigations and what users need to take care of. Following up on last year's talk (https://events.opensuse.org/conference/oSC17/program/proposal/1246) I intend to give an update on hardware support in openSUSE and software support for new boards. This will include an update on Meltdown/Spectre mitigations and what users need to take care of. about this event: https://c3voc.de 00:44:34 https://media.ccc.de/v/1831-rethinking-opensuse-release-tooling-and-the-build-service Over the last year I have completed a large amount of work on the tools integral to the openSUSE release process and as such have become familiar with the scope, workflow, and general problems involved. After mulling over these general shortcomings it becomes clear that taking a step back and rethinking some core concepts such as the build service and the way the release tools interact with it is necessary. I have since explored and prototyped a new approach that should drastically reduce the maintenance burden on the openSUSE project while solving major pitfalls, improving transparency, solving a large number of open feature requests, and providing entirely new options. At this point it seems appropriate to present the concept and prototype to a wider audience before investing too much further. Hopefully, the openSUSE community will be as excited about this direction as I am. To start, some background on the type of work being done over the last year will be provided. Metrics will be provided to demonstrate the effect and importance of the work. After which details of pitfalls that force a cumbersome workflow will be provided in addition to covering some feature requests and general improvements desired for release work. The new approach will then be explained and how it resolves a large number of these problems while drastically reducing the overall code-base. With the reduction in the code-base along with adapting modern practices it should be easier to involve new contributors. Preferably key stake holders from OBS and release teams will be present and participate in a healthy discussion. Over the last year I have completed a large amount of work on the tools integral to the openSUSE release process and as such have become familiar with the scope, workflow, and general problems involved. After mulling over these general shortcomings it becomes clear that taking a step back and rethinking some core concepts such as the build service and the way the release tools interact with it is necessary. I have since explored and prototyped a new approach that should drastically reduce the maintenance burden on the openSUSE project while solving major pitfalls, improving transparency, solving a large number of open feature requests, and providing entirely new options. At this point it seems appropriate to present the concept and prototype to a wider audience before investing too much further. Hopefully, the openSUSE community will be as excited about this direction as I am. To start, some background on the type of work being done over the last year will be provided. Metrics will be provided to demonstrate the effect and importance of the work. After which details of pitfalls that force a cumbersome workflow will be provided in addition to covering some feature requests and general improvements desired for release work. The new approach will then be explained and how it resolves a large number of these problems while drastically reducing the overall code-base. With the reduction in the code-base along with adapting modern practices it should be easier to involve new contributors. Preferably key stake holders from OBS and release teams will be present and participate in a healthy discussion. about this event: https://c3voc.de Sun, 27 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1831-eng-Rethinking_openSUSE_release_tooling_and_the_build_service_hd.mp4?1527416147 IZHSaVLWgShm-bPA9qhEuw 2018-05-27T00:00:00+02:00 Jimmy Berry No osc18, 1831, openSUSE Simplify, improve, and increase transparency Over the last year I have completed a large amount of work on the tools integral to the openSUSE release process and as such have become familiar with the scope, workflow, and general problems involved. After mulling over these general shortcomings it becomes clear that taking a step back and rethinking some core concepts such as the build service and the way the release tools interact with it is necessary. I have since explored and prototyped a new approach that should drastically reduce the maintenance burden on the openSUSE project while solving major pitfalls, improving transparency, solving a large number of open feature requests, and providing entirely new options. At this point it seems appropriate to present the concept and prototype to a wider audience before investing too much further. Hopefully, the openSUSE community will be as excited about this direction as I am. To start, some background on the type of work being done over the last year will be provided. Metrics will be provided to demonstrate the effect and importance of the work. After which details of pitfalls that force a cumbersome workflow will be provided in addition to covering some feature requests and general improvements desired for release work. The new approach will then be explained and how it resolves a large number of these problems while drastically reducing the overall code-base. With the reduction in the code-base along with adapting modern practices it should be easier to involve new contributors. Preferably key stake holders from OBS and release teams will be present and participate in a healthy discussion. Over the last year I have completed a large amount of work on the tools integral to the openSUSE release process and as such have become familiar with the scope, workflow, and general problems involved. After mulling over these general shortcomings it becomes clear that taking a step back and rethinking some core concepts such as the build service and the way the release tools interact with it is necessary. I have since explored and prototyped a new approach that should drastically reduce the maintenance burden on the openSUSE project while solving major pitfalls, improving transparency, solving a large number of open feature requests, and providing entirely new options. At this point it seems appropriate to present the concept and prototype to a wider audience before investing too much further. Hopefully, the openSUSE community will be as excited about this direction as I am. To start, some background on the type of work being done over the last year will be provided. Metrics will be provided to demonstrate the effect and importance of the work. After which details of pitfalls that force a cumbersome workflow will be provided in addition to covering some feature requests and general improvements desired for release work. The new approach will then be explained and how it resolves a large number of these problems while drastically reducing the overall code-base. With the reduction in the code-base along with adapting modern practices it should be easier to involve new contributors. Preferably key stake holders from OBS and release teams will be present and participate in a healthy discussion. about this event: https://c3voc.de 00:30:31 https://media.ccc.de/v/1861-cross-compilers-for-lizards-two-years-later A few years ago we started adding cross-compiler packages to Tumbleweed, based on our maintained GCC packages. There have been two recent toolchain additions, more are still in the works, and several challenges remain - such as on our end Leap and PackageHub. A few years ago we started adding cross-compiler packages to Tumbleweed, based on our maintained GCC packages. There have been two recent toolchain additions, more are still in the works, and several challenges remain - such as on our end Leap and PackageHub. about this event: https://c3voc.de Sun, 27 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1861-eng-Cross-compilers_for_lizards_two_years_later_hd.mp4?1527412725 ETwO2kTkiqDeR95Z3UEYZg 2018-05-27T00:00:00+02:00 Andreas Färber No osc18, 1861, Embedded Systems Improving the microcontroller tooling A few years ago we started adding cross-compiler packages to Tumbleweed, based on our maintained GCC packages. There have been two recent toolchain additions, more are still in the works, and several challenges remain - such as on our end Leap and PackageHub. A few years ago we started adding cross-compiler packages to Tumbleweed, based on our maintained GCC packages. There have been two recent toolchain additions, more are still in the works, and several challenges remain - such as on our end Leap and PackageHub. about this event: https://c3voc.de 00:24:47 https://media.ccc.de/v/1885-what-s-new-in-obs Open Build Service (OBS) development has increased in an exponential way. David will briefly explain the evolution of the OBS frontend in the last year, and also some of the awesome features that have been included recently. Kiwi Editor, Cloud Uploader features that are already available will not be the only ones we will talk about. Adrian will talk about the new OBS backend features as Docker build support, AppImage, Docker registry, etc. And last but not least, Marco will introduce us to OSC new features. We will also give some hints about the upcoming features we have in mind for the future of OBS. Sounds interesting, right? Don't miss this talk and take advantage of knowing all the improvements that can make your work easier using OBS. Open Build Service (OBS) development has increased in an exponential way. David will briefly explain the evolution of the OBS frontend in the last year, and also some of the awesome features that have been included recently. Kiwi Editor, Cloud Uploader features that are already available will not be the only ones we will talk about. Adrian will talk about the new OBS backend features as Docker build support, AppImage, Docker registry, etc. And last but not least, Marco will introduce us to OSC new features. We will also give some hints about the upcoming features we have in mind for the future of OBS. Sounds interesting, right? Don't miss this talk and take advantage of knowing all the improvements that can make your work easier using OBS. about this event: https://c3voc.de Sun, 27 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1885-eng-Whats_new_in_OBS_hd.mp4?1527411585 wH433cPdvbX3qo5fUFKgbA 2018-05-27T00:00:00+02:00 David Kang No osc18, 1885, openSUSE Latest new features and how to use them Open Build Service (OBS) development has increased in an exponential way. David will briefly explain the evolution of the OBS frontend in the last year, and also some of the awesome features that have been included recently. Kiwi Editor, Cloud Uploader features that are already available will not be the only ones we will talk about. Adrian will talk about the new OBS backend features as Docker build support, AppImage, Docker registry, etc. And last but not least, Marco will introduce us to OSC new features. We will also give some hints about the upcoming features we have in mind for the future of OBS. Sounds interesting, right? Don't miss this talk and take advantage of knowing all the improvements that can make your work easier using OBS. Open Build Service (OBS) development has increased in an exponential way. David will briefly explain the evolution of the OBS frontend in the last year, and also some of the awesome features that have been included recently. Kiwi Editor, Cloud Uploader features that are already available will not be the only ones we will talk about. Adrian will talk about the new OBS backend features as Docker build support, AppImage, Docker registry, etc. And last but not least, Marco will introduce us to OSC new features. We will also give some hints about the upcoming features we have in mind for the future of OBS. Sounds interesting, right? Don't miss this talk and take advantage of knowing all the improvements that can make your work easier using OBS. about this event: https://c3voc.de 00:22:22 https://media.ccc.de/v/1966-30-seconds-to-code Creating development setups can be tedious, error-prone and quite horrifying to novice contributors of Open Source projects. You would set up a virtual machine, install the required software and spend quite some time configuring it. On top of this, your setup would require maintenance and updates. A more modern approach is featured in this talk: Create a reproducible environment, have automatic updates to new package versions just by using OBS to build your Docker container image from RPMs and a kiwi XML file. No more fiddling with VMs, no more manual install and configuration marathons - just download and run your ready-to-use Docker image from OBS. Creating development setups can be tedious, error-prone and quite horrifying to novice contributors of Open Source projects. You would set up a virtual machine, install the required software and spend quite some time configuring it. On top of this, your setup would require maintenance and updates. A more modern approach is featured in this talk: Create a reproducible environment, have automatic updates to new package versions just by using OBS to build your Docker container image from RPMs and a kiwi XML file. No more fiddling with VMs, no more manual install and configuration marathons - just download and run your ready-to-use Docker image from OBS. about this event: https://c3voc.de Sun, 27 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1966-eng-30_seconds_to_Code_hd.mp4?1527411554 3MfGfpdGhvnKiXmdqgvykA 2018-05-27T00:00:00+02:00 Ralf Lang No osc18, 1966, Cloud and Containers Streamlining development setups with Docker and Open Build Service Creating development setups can be tedious, error-prone and quite horrifying to novice contributors of Open Source projects. You would set up a virtual machine, install the required software and spend quite some time configuring it. On top of this, your setup would require maintenance and updates. A more modern approach is featured in this talk: Create a reproducible environment, have automatic updates to new package versions just by using OBS to build your Docker container image from RPMs and a kiwi XML file. No more fiddling with VMs, no more manual install and configuration marathons - just download and run your ready-to-use Docker image from OBS. Creating development setups can be tedious, error-prone and quite horrifying to novice contributors of Open Source projects. You would set up a virtual machine, install the required software and spend quite some time configuring it. On top of this, your setup would require maintenance and updates. A more modern approach is featured in this talk: Create a reproducible environment, have automatic updates to new package versions just by using OBS to build your Docker container image from RPMs and a kiwi XML file. No more fiddling with VMs, no more manual install and configuration marathons - just download and run your ready-to-use Docker image from OBS. about this event: https://c3voc.de 00:25:43 https://media.ccc.de/v/1933-apparmor-3-and-beyond There are several changes coming with the release of AppArmor 3. This talk will cover the changes that AppArmor 3 will bring and how the changes will affect policy and confinement. It will cover policy versioning, local vs pre-shipped read-only policy text, improvements in AppArmor policy namespaces, fine grained network and d-bus mediation as well as IMA integration. There are several changes coming with the release of AppArmor 3. This talk will cover the changes that AppArmor 3 will bring and how the changes will affect policy and confinement. It will cover policy versioning, local vs pre-shipped read-only policy text, improvements in AppArmor policy namespaces, fine grained network and d-bus mediation as well as IMA integration. about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1933-eng-AppArmor_3_and_beyond_hd.mp4?1527354947 Vhm3GQebxdtzVPq4uFTaPA 2018-05-26T00:00:00+02:00 John Johansen No osc18, 1933, openSUSE riding the Tumbleweed There are several changes coming with the release of AppArmor 3. This talk will cover the changes that AppArmor 3 will bring and how the changes will affect policy and confinement. It will cover policy versioning, local vs pre-shipped read-only policy text, improvements in AppArmor policy namespaces, fine grained network and d-bus mediation as well as IMA integration. There are several changes coming with the release of AppArmor 3. This talk will cover the changes that AppArmor 3 will bring and how the changes will affect policy and confinement. It will cover policy versioning, local vs pre-shipped read-only policy text, improvements in AppArmor policy namespaces, fine grained network and d-bus mediation as well as IMA integration. about this event: https://c3voc.de 00:29:00 https://media.ccc.de/v/1957-suse-package-hub-community-packages-for-enterprise-users SUSE Package Hub [1] provides open source packages to Enterprise Users by the Community. This talk shows the current status of this project, explains how to contribute and what might be next. [1] https://packagehub.suse.com SUSE Package Hub [1] provides open source packages to Enterprise Users by the Community. This talk shows the current status of this project, explains how to contribute and what might be next. [1] https://packagehub.suse.com about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1957-eng-SUSE_Package_Hub_-_Community_packages_for_Enterprise_Users_hd.mp4?1527354914 z640iNCKx5acHqxLYhkbSw 2018-05-26T00:00:00+02:00 Wolfgang Engel No osc18, 1957, Open Source SUSE Package Hub [1] provides open source packages to Enterprise Users by the Community. This talk shows the current status of this project, explains how to contribute and what might be next. [1] https://packagehub.suse.com SUSE Package Hub [1] provides open source packages to Enterprise Users by the Community. This talk shows the current status of this project, explains how to contribute and what might be next. [1] https://packagehub.suse.com about this event: https://c3voc.de 00:21:16 https://media.ccc.de/v/1876-devops-for-gnome-with-flatpak As probably you might know, GNOME hasn't been the most updated in technologies & processes used for the design, development, testing, QA, delivery loop. To be honest, we have been quite behind! Build fails, not passing tests, contributors stuck with trivial details, each product with different released days, designers and QA in need to build the whole stack to try out a minimal UI change... well, we could continue indefinitely. Needless to say this was a huge impact in our performance and contributor friendliness, even more in a time where web applications are as common. Fortunately, things has changed dramatically over the last two years, specially with Flatpak for a containerized-alike build and distribution of apps and our move to GitLab and its integrated CI, we are able to fully dive into integrating a more DevOps oriented workflow. This effort has become a dream come true for GNOME, that we would have never imagined a few years back. In this talk I will present and explain in details how to use and integrate Flatpak and GitLab together to create the future of the DevOps experience for Linux applications development and how we use it at GNOME and what impact is making to our organization. As probably you might know, GNOME hasn't been the most updated in technologies & processes used for the design, development, testing, QA, delivery loop. To be honest, we have been quite behind! Build fails, not passing tests, contributors stuck with trivial details, each product with different released days, designers and QA in need to build the whole stack to try out a minimal UI change... well, we could continue indefinitely. Needless to say this was a huge impact in our performance and contributor friendliness, even more in a time where web applications are as common. Fortunately, things has changed dramatically over the last two years, specially with Flatpak for a containerized-alike build and distribution of apps and our move to GitLab and its integrated CI, we are able to fully dive into integrating a more DevOps oriented workflow. This effort has become a dream come true for GNOME, that we would have never imagined a few years back. In this talk I will present and explain in details how to use and integrate Flatpak and GitLab together to create the future of the DevOps experience for Linux applications development and how we use it at GNOME and what impact is making to our organization. about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1876-eng-DevOps_for_GNOME_with_Flatpak_hd.mp4?1527354309 R-pD0Fv2VLbFIaL_sQA1mw 2018-05-26T00:00:00+02:00 Carlos Soriano No osc18, 1876, Desktop and Applications And how we improved our contributors experience and exposure of the happenings of GNOME As probably you might know, GNOME hasn't been the most updated in technologies & processes used for the design, development, testing, QA, delivery loop. To be honest, we have been quite behind! Build fails, not passing tests, contributors stuck with trivial details, each product with different released days, designers and QA in need to build the whole stack to try out a minimal UI change... well, we could continue indefinitely. Needless to say this was a huge impact in our performance and contributor friendliness, even more in a time where web applications are as common. Fortunately, things has changed dramatically over the last two years, specially with Flatpak for a containerized-alike build and distribution of apps and our move to GitLab and its integrated CI, we are able to fully dive into integrating a more DevOps oriented workflow. This effort has become a dream come true for GNOME, that we would have never imagined a few years back. In this talk I will present and explain in details how to use and integrate Flatpak and GitLab together to create the future of the DevOps experience for Linux applications development and how we use it at GNOME and what impact is making to our organization. As probably you might know, GNOME hasn't been the most updated in technologies & processes used for the design, development, testing, QA, delivery loop. To be honest, we have been quite behind! Build fails, not passing tests, contributors stuck with trivial details, each product with different released days, designers and QA in need to build the whole stack to try out a minimal UI change... well, we could continue indefinitely. Needless to say this was a huge impact in our performance and contributor friendliness, even more in a time where web applications are as common. Fortunately, things has changed dramatically over the last two years, specially with Flatpak for a containerized-alike build and distribution of apps and our move to GitLab and its integrated CI, we are able to fully dive into integrating a more DevOps oriented workflow. This effort has become a dream come true for GNOME, that we would have never imagined a few years back. In this talk I will present and explain in details how to use and integrate Flatpak and GitLab together to create the future of the DevOps experience for Linux applications development and how we use it at GNOME and what impact is making to our organization. about this event: https://c3voc.de 00:21:32 https://media.ccc.de/v/1915-btrfs-is-awesome-except-when-it-isn-t I love btrfs, I think btrfs is the best filesystem ever. But like all software, it's not absolutely 100% perfect all of the time. This lightning talk will help tell you what to do when it all goes wrong :) I love btrfs, I think btrfs is the best filesystem ever. But like all software, it's not absolutely 100% perfect all of the time. This lightning talk will help tell you what to do when it all goes wrong :) about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1915-eng-btrfs_is_awesome_except_when_it_isnt_hd.mp4?1527352602 6S4ivpZLdGJZeHS-EG1JEg 2018-05-26T00:00:00+02:00 Richard Brown No osc18, 1915, Open Source How to fix a broken btrfs filesystem I love btrfs, I think btrfs is the best filesystem ever. But like all software, it's not absolutely 100% perfect all of the time. This lightning talk will help tell you what to do when it all goes wrong :) I love btrfs, I think btrfs is the best filesystem ever. But like all software, it's not absolutely 100% perfect all of the time. This lightning talk will help tell you what to do when it all goes wrong :) about this event: https://c3voc.de 00:17:12 https://media.ccc.de/v/1801-roadrunner-securing-services-with-letsencrypt While the need for encrypted web sites has been sufficiently motivated by countless revelations on state sponsored surveillance or malevolent ISPs, acquiring a LetsEncrypt certificate used to be a tiresome business, and usually certificates broke anyway. openSUSE Leap 15 will be the first long term distribution to provide automated certificate requests and renewals thanks to dehydrated, which is also available for older distributions via OBS. This talk will show how to quickly acquire certificates for a single host and ensure that they will be automatically renewed and how to orchestrate certificate renewal for a whole fleet of servers and services via DNS. Finally, we will also look into further and future simplification for single services, such as Caddy or Apache's mod_md. While the need for encrypted web sites has been sufficiently motivated by countless revelations on state sponsored surveillance or malevolent ISPs, acquiring a LetsEncrypt certificate used to be a tiresome business, and usually certificates broke anyway. openSUSE Leap 15 will be the first long term distribution to provide automated certificate requests and renewals thanks to dehydrated, which is also available for older distributions via OBS. This talk will show how to quickly acquire certificates for a single host and ensure that they will be automatically renewed and how to orchestrate certificate renewal for a whole fleet of servers and services via DNS. Finally, we will also look into further and future simplification for single services, such as Caddy or Apache's mod_md. about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1801-eng-Roadrunner_Securing_services_with_LetsEncrypt_hd.mp4?1527352548 soYBFN3ak9aYMoYkTP-F-g 2018-05-26T00:00:00+02:00 Daniel Molkentin No osc18, 1801, openSUSE Why you should no longer be afraid of using TLS While the need for encrypted web sites has been sufficiently motivated by countless revelations on state sponsored surveillance or malevolent ISPs, acquiring a LetsEncrypt certificate used to be a tiresome business, and usually certificates broke anyway. openSUSE Leap 15 will be the first long term distribution to provide automated certificate requests and renewals thanks to dehydrated, which is also available for older distributions via OBS. This talk will show how to quickly acquire certificates for a single host and ensure that they will be automatically renewed and how to orchestrate certificate renewal for a whole fleet of servers and services via DNS. Finally, we will also look into further and future simplification for single services, such as Caddy or Apache's mod_md. While the need for encrypted web sites has been sufficiently motivated by countless revelations on state sponsored surveillance or malevolent ISPs, acquiring a LetsEncrypt certificate used to be a tiresome business, and usually certificates broke anyway. openSUSE Leap 15 will be the first long term distribution to provide automated certificate requests and renewals thanks to dehydrated, which is also available for older distributions via OBS. This talk will show how to quickly acquire certificates for a single host and ensure that they will be automatically renewed and how to orchestrate certificate renewal for a whole fleet of servers and services via DNS. Finally, we will also look into further and future simplification for single services, such as Caddy or Apache's mod_md. about this event: https://c3voc.de 00:34:54 https://media.ccc.de/v/1723-learn-how-to-add-functionality-to-the-mysql-server-a-guided-tour Ever wanted to learn how to add this little piece of functionality that you're missing in MySQL but the codebase seems large and thus intimidating ? Then this talk is for you: we'll enumerate the ways to extend and alter MySQL functionality and will get you started on hacking on the codebase: what the layout is like and where to fund stuff and documentation to support you. We will also review the state of the doxygen project in MySQL 8.0. The talk assumes you'd have working knowledge with C/C++ and algorithms. Ever wanted to learn how to add this little piece of functionality that you're missing in MySQL but the codebase seems large and thus intimidating ? Then this talk is for you: we'll enumerate the ways to extend and alter MySQL functionality and will get you started on hacking on the codebase: what the layout is like and where to fund stuff and documentation to support you. We will also review the state of the doxygen project in MySQL 8.0. The talk assumes you'd have working knowledge with C/C++ and algorithms. about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1723-eng-Learn_how_to_add_functionality_to_the_MySQL_server_a_guided_tour_hd.mp4?1527352335 Kz4d4Wkhmr7KkKNfZwbdTQ 2018-05-26T00:00:00+02:00 Georgi Kodinov No osc18, 1723, Open Source Hack on the MySQL code for fun and profit ! Ever wanted to learn how to add this little piece of functionality that you're missing in MySQL but the codebase seems large and thus intimidating ? Then this talk is for you: we'll enumerate the ways to extend and alter MySQL functionality and will get you started on hacking on the codebase: what the layout is like and where to fund stuff and documentation to support you. We will also review the state of the doxygen project in MySQL 8.0. The talk assumes you'd have working knowledge with C/C++ and algorithms. Ever wanted to learn how to add this little piece of functionality that you're missing in MySQL but the codebase seems large and thus intimidating ? Then this talk is for you: we'll enumerate the ways to extend and alter MySQL functionality and will get you started on hacking on the codebase: what the layout is like and where to fund stuff and documentation to support you. We will also review the state of the doxygen project in MySQL 8.0. The talk assumes you'd have working knowledge with C/C++ and algorithms. about this event: https://c3voc.de 00:28:44 https://media.ccc.de/v/1954-let-s-talk-about-opensuse-leap-kernels With openSUSE Leap, we've tried a new management model based on SLE. The same is true for the kernel, one of the most "core" packages in the whole distribution. However, in the case of kernels, a story is a bit different from others. In this talk, we'll take a look back at the history of openSUSE Leap kernel developments and maintenance from Leap 42.1 to 42.3, covering briefly about the concept of openSUSE Leap kernels, how they are packaged, and how they are maintained. This will show us a light and a shadow in the paths we've gone through, as well as the open question to a future development of Leap 15 series. With openSUSE Leap, we've tried a new management model based on SLE. The same is true for the kernel, one of the most "core" packages in the whole distribution. However, in the case of kernels, a story is a bit different from others. In this talk, we'll take a look back at the history of openSUSE Leap kernel developments and maintenance from Leap 42.1 to 42.3, covering briefly about the concept of openSUSE Leap kernels, how they are packaged, and how they are maintained. This will show us a light and a shadow in the paths we've gone through, as well as the open question to a future development of Leap 15 series. about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1954-eng-Lets_Talk_about_openSUSE_Leap_Kernels_hd.mp4?1527352271 J7lXO9IfXYPCjLl7_YZZyg 2018-05-26T00:00:00+02:00 Takashi Iwai No osc18, 1954, openSUSE With openSUSE Leap, we've tried a new management model based on SLE. The same is true for the kernel, one of the most "core" packages in the whole distribution. However, in the case of kernels, a story is a bit different from others. In this talk, we'll take a look back at the history of openSUSE Leap kernel developments and maintenance from Leap 42.1 to 42.3, covering briefly about the concept of openSUSE Leap kernels, how they are packaged, and how they are maintained. This will show us a light and a shadow in the paths we've gone through, as well as the open question to a future development of Leap 15 series. With openSUSE Leap, we've tried a new management model based on SLE. The same is true for the kernel, one of the most "core" packages in the whole distribution. However, in the case of kernels, a story is a bit different from others. In this talk, we'll take a look back at the history of openSUSE Leap kernel developments and maintenance from Leap 42.1 to 42.3, covering briefly about the concept of openSUSE Leap kernels, how they are packaged, and how they are maintained. This will show us a light and a shadow in the paths we've gone through, as well as the open question to a future development of Leap 15 series. about this event: https://c3voc.de 00:31:09 https://media.ccc.de/v/1906-transactional-updates-deep-dive With the release of Leap 15 the new system role called "Transactional Server" will be available during the installation, so this is the perfect opportunity to have a look at the concept behind it and how to work with such a system in practice. In this talk we will have a look at transactional-updates from different angles: * The basic concepts behind transactional-update * How to use the Transactional Server or Kubic (Users & Administrators) * Packaging for transactional systems (Packagers) * How transactional-update compares to other solutions from various distributions (Developers) * Recent developments in the transactional-update world With the release of Leap 15 the new system role called "Transactional Server" will be available during the installation, so this is the perfect opportunity to have a look at the concept behind it and how to work with such a system in practice. In this talk we will have a look at transactional-updates from different angles: * The basic concepts behind transactional-update * How to use the Transactional Server or Kubic (Users & Administrators) * Packaging for transactional systems (Packagers) * How transactional-update compares to other solutions from various distributions (Developers) * Recent developments in the transactional-update world about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1906-eng-Transactional_Updates_-_deep_dive_hd.mp4?1527352156 WmeY30m_4yml6Z5Ffp-EbA 2018-05-26T00:00:00+02:00 Ignaz Forster No osc18, 1906, Open Source How to update your systems without breaking them With the release of Leap 15 the new system role called "Transactional Server" will be available during the installation, so this is the perfect opportunity to have a look at the concept behind it and how to work with such a system in practice. In this talk we will have a look at transactional-updates from different angles: * The basic concepts behind transactional-update * How to use the Transactional Server or Kubic (Users & Administrators) * Packaging for transactional systems (Packagers) * How transactional-update compares to other solutions from various distributions (Developers) * Recent developments in the transactional-update world With the release of Leap 15 the new system role called "Transactional Server" will be available during the installation, so this is the perfect opportunity to have a look at the concept behind it and how to work with such a system in practice. In this talk we will have a look at transactional-updates from different angles: * The basic concepts behind transactional-update * How to use the Transactional Server or Kubic (Users & Administrators) * Packaging for transactional systems (Packagers) * How transactional-update compares to other solutions from various distributions (Developers) * Recent developments in the transactional-update world about this event: https://c3voc.de 00:33:51 https://media.ccc.de/v/1792-the-new-eu-cybersecurity-act Fibre to the home opens numerous interesting possibilities for both bona-fide and not so bona-fide use cases. Having your espresso machine or refrigerator being part of a multi-million device botnet which is attacking critical infrastructure might not necessarily be your first association when zipping your early morning caffeine fix. Not only might this notion be somewhat disruptive for your early morning zen-moment, you might also be held legally accountable for these actions as it is actually your home network participating in an international attack wreaking havoc on, let’s say, the healthcare information system of a close NATO ally. Nowadays there is zero quality control being enforced over internet connected devices in general. But the EU (and US) have decided this somewhat naive approach should come to an end. A new directive (NIS, Directive on the Security of Network and Information Systems) comes into effect. Especially for branches active in the development of internet connected devices with a direct application in the “quality of life improvement” domain, this will be something to look out for: Medical devices Automotive Domotica This new directive includes the ambition of implementing a certification scheme for IT systems and devices, this scheme will be based on the existing ISO 15408 standard: “ISO/IEC 15408-1:2009 establishes the general concepts and principles of IT security evaluation and specifies the general model of evaluation given by various parts of ISO/IEC 15408 which in its entirety is meant to be used as the basis for evaluation of security properties of IT products.” What does this standard encompass? What does open-source and free software have to do with this? Let’s have a closer look in this talk! Fibre to the home opens numerous interesting possibilities for both bona-fide and not so bona-fide use cases. Having your espresso machine or refrigerator being part of a multi-million device botnet which is attacking critical infrastructure might not necessarily be your first association when zipping your early morning caffeine fix. Not only might this notion be somewhat disruptive for your early morning zen-moment, you might also be held legally accountable for these actions as it is actually your home network participating in an international attack wreaking havoc on, let’s say, the healthcare information system of a close NATO ally. Nowadays there is zero quality control being enforced over internet connected devices in general. But the EU (and US) have decided this somewhat naive approach should come to an end. A new directive (NIS, Directive on the Security of Network and Information Systems) comes into effect. Especially for branches active in the development of internet connected devices with a direct application in the “quality of life improvement” domain, this will be something to look out for: Medical devices Automotive Domotica This new directive includes the ambition of implementing a certification scheme for IT systems and devices, this scheme will be based on the existing ISO 15408 standard: “ISO/IEC 15408-1:2009 establishes the general concepts and principles of IT security evaluation and specifies the general model of evaluation given by various parts of ISO/IEC 15408 which in its entirety is meant to be used as the basis for evaluation of security properties of IT products.” What does this standard encompass? What does open-source and free software have to do with this? Let’s have a closer look in this talk! about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1792-eng-The_new_EU_CyberSecurity_Act_hd.mp4?1527352130 fdFmy93w2hAWoGTUD8J1DA 2018-05-26T00:00:00+02:00 Hans de Raad No osc18, 1792, Open Source Or how to prevent the EU from becoming the worlds largest botnet honeypot Fibre to the home opens numerous interesting possibilities for both bona-fide and not so bona-fide use cases. Having your espresso machine or refrigerator being part of a multi-million device botnet which is attacking critical infrastructure might not necessarily be your first association when zipping your early morning caffeine fix. Not only might this notion be somewhat disruptive for your early morning zen-moment, you might also be held legally accountable for these actions as it is actually your home network participating in an international attack wreaking havoc on, let’s say, the healthcare information system of a close NATO ally. Nowadays there is zero quality control being enforced over internet connected devices in general. But the EU (and US) have decided this somewhat naive approach should come to an end. A new directive (NIS, Directive on the Security of Network and Information Systems) comes into effect. Especially for branches active in the development of internet connected devices with a direct application in the “quality of life improvement” domain, this will be something to look out for: Medical devices Automotive Domotica This new directive includes the ambition of implementing a certification scheme for IT systems and devices, this scheme will be based on the existing ISO 15408 standard: “ISO/IEC 15408-1:2009 establishes the general concepts and principles of IT security evaluation and specifies the general model of evaluation given by various parts of ISO/IEC 15408 which in its entirety is meant to be used as the basis for evaluation of security properties of IT products.” What does this standard encompass? What does open-source and free software have to do with this? Let’s have a closer look in this talk! Fibre to the home opens numerous interesting possibilities for both bona-fide and not so bona-fide use cases. Having your espresso machine or refrigerator being part of a multi-million device botnet which is attacking critical infrastructure might not necessarily be your first association when zipping your early morning caffeine fix. Not only might this notion be somewhat disruptive for your early morning zen-moment, you might also be held legally accountable for these actions as it is actually your home network participating in an international attack wreaking havoc on, let’s say, the healthcare information system of a close NATO ally. Nowadays there is zero quality control being enforced over internet connected devices in general. But the EU (and US) have decided this somewhat naive approach should come to an end. A new directive (NIS, Directive on the Security of Network and Information Systems) comes into effect. Especially for branches active in the development of internet connected devices with a direct application in the “quality of life improvement” domain, this will be something to look out for: Medical devices Automotive Domotica This new directive includes the ambition of implementing a certification scheme for IT systems and devices, this scheme will be based on the existing ISO 15408 standard: “ISO/IEC 15408-1:2009 establishes the general concepts and principles of IT security evaluation and specifies the general model of evaluation given by various parts of ISO/IEC 15408 which in its entirety is meant to be used as the basis for evaluation of security properties of IT products.” What does this standard encompass? What does open-source and free software have to do with this? Let’s have a closer look in this talk! about this event: https://c3voc.de 00:47:14 https://media.ccc.de/v/1963-new-yast-storage-stack-technical-overview YaST comes with a brand new storage stack. The packages libstorage and yast2-storage have been replaced by the new libstorage-ng and yast2-storage-ng. YaST team has put a lot effort on having its new storage ready for openSUSE Leap 15 (and SUSE SLE 15), and now it is time to present how it works. In this presentation we will explain storage-ng from a technical point of view. For example, we will discuss the current algorithm used by the automatic proposal: how it decides what devices should be removed, how to configure its behavior and how it works in several scenarios. Also, we will see some details about how AutoYaST uses and interacts with the new storage stack. This talk is a good opportunity to get feedback from the openSUSE community, and we can discuss how our tools can be improved in future. YaST comes with a brand new storage stack. The packages libstorage and yast2-storage have been replaced by the new libstorage-ng and yast2-storage-ng. YaST team has put a lot effort on having its new storage ready for openSUSE Leap 15 (and SUSE SLE 15), and now it is time to present how it works. In this presentation we will explain storage-ng from a technical point of view. For example, we will discuss the current algorithm used by the automatic proposal: how it decides what devices should be removed, how to configure its behavior and how it works in several scenarios. Also, we will see some details about how AutoYaST uses and interacts with the new storage stack. This talk is a good opportunity to get feedback from the openSUSE community, and we can discuss how our tools can be improved in future. about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1963-eng-New_YaST_storage_stack_technical_overview_hd.mp4?1527352067 TCLF0wHkCHABlw79YGgBoA 2018-05-26T00:00:00+02:00 José Iván López González No osc18, 1963, openSUSE YaST comes with a brand new storage stack. The packages libstorage and yast2-storage have been replaced by the new libstorage-ng and yast2-storage-ng. YaST team has put a lot effort on having its new storage ready for openSUSE Leap 15 (and SUSE SLE 15), and now it is time to present how it works. In this presentation we will explain storage-ng from a technical point of view. For example, we will discuss the current algorithm used by the automatic proposal: how it decides what devices should be removed, how to configure its behavior and how it works in several scenarios. Also, we will see some details about how AutoYaST uses and interacts with the new storage stack. This talk is a good opportunity to get feedback from the openSUSE community, and we can discuss how our tools can be improved in future. YaST comes with a brand new storage stack. The packages libstorage and yast2-storage have been replaced by the new libstorage-ng and yast2-storage-ng. YaST team has put a lot effort on having its new storage ready for openSUSE Leap 15 (and SUSE SLE 15), and now it is time to present how it works. In this presentation we will explain storage-ng from a technical point of view. For example, we will discuss the current algorithm used by the automatic proposal: how it decides what devices should be removed, how to configure its behavior and how it works in several scenarios. Also, we will see some details about how AutoYaST uses and interacts with the new storage stack. This talk is a good opportunity to get feedback from the openSUSE community, and we can discuss how our tools can be improved in future. about this event: https://c3voc.de 00:31:28 https://media.ccc.de/v/1942-saltboot-salt-managed-pxe-boot In the time of clouds and virtual computing it seems, there is no longer space for a large real-hardware-based OS deployments. But what schools use in their classrooms? What is beneath ATMs, info kiosks, cash registers? For there devices real network OS deployment is still crucial. This talk is about exactly that. Well known network PXE boot, but upgraded with Salt, a modern configuration management engine, to automate and secure the process. We will go from basic setup, through salt integration in netboot initrd and to salt states to make all of this possible and more. In the time of clouds and virtual computing it seems, there is no longer space for a large real-hardware-based OS deployments. But what schools use in their classrooms? What is beneath ATMs, info kiosks, cash registers? For there devices real network OS deployment is still crucial. This talk is about exactly that. Well known network PXE boot, but upgraded with Salt, a modern configuration management engine, to automate and secure the process. We will go from basic setup, through salt integration in netboot initrd and to salt states to make all of this possible and more. about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1942-eng-Saltboot_-_Salt_managed_PXE_boot_hd.mp4?1527352038 FYGInk6xUS9vg93ODzaNhw 2018-05-26T00:00:00+02:00 Ondrej Holecek No osc18, 1942, Open Source In the time of clouds and virtual computing it seems, there is no longer space for a large real-hardware-based OS deployments. But what schools use in their classrooms? What is beneath ATMs, info kiosks, cash registers? For there devices real network OS deployment is still crucial. This talk is about exactly that. Well known network PXE boot, but upgraded with Salt, a modern configuration management engine, to automate and secure the process. We will go from basic setup, through salt integration in netboot initrd and to salt states to make all of this possible and more. In the time of clouds and virtual computing it seems, there is no longer space for a large real-hardware-based OS deployments. But what schools use in their classrooms? What is beneath ATMs, info kiosks, cash registers? For there devices real network OS deployment is still crucial. This talk is about exactly that. Well known network PXE boot, but upgraded with Salt, a modern configuration management engine, to automate and secure the process. We will go from basic setup, through salt integration in netboot initrd and to salt states to make all of this possible and more. about this event: https://c3voc.de 00:43:29 https://media.ccc.de/v/1804-what-storage-ng-will-bring-and-what-else-do-you-want As many openSUSE users may know, two of the most important YaST components, libstorage and yast2-storage, were recently rewritten from scratch in order to ease the maintenance and to be prepared for whatever the future brings. Now we have a solid base to adapt the current behavior without compromising the existing supported scenarios and to implement new and shiny features. During this presentation we will explain the present and the plans for the supported installation scenarios, for the partitioning proposal (a.k.a. Guided Setup) and for our beloved Partitioner. We need help from the openSUSE community to review and refine those plans and to bring new ideas to the table. Bring your storage wish list! As many openSUSE users may know, two of the most important YaST components, libstorage and yast2-storage, were recently rewritten from scratch in order to ease the maintenance and to be prepared for whatever the future brings. Now we have a solid base to adapt the current behavior without compromising the existing supported scenarios and to implement new and shiny features. During this presentation we will explain the present and the plans for the supported installation scenarios, for the partitioning proposal (a.k.a. Guided Setup) and for our beloved Partitioner. We need help from the openSUSE community to review and refine those plans and to bring new ideas to the table. Bring your storage wish list! about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1804-eng-What_Storage-ng_will_bring_and_what_else_do_YOU_want_hd.mp4?1527351947 gSkZwkBoI2cAIYA29-UNHQ 2018-05-26T00:00:00+02:00 Ancor González Sosa No osc18, 1804, openSUSE Help us to shape the future of YaST As many openSUSE users may know, two of the most important YaST components, libstorage and yast2-storage, were recently rewritten from scratch in order to ease the maintenance and to be prepared for whatever the future brings. Now we have a solid base to adapt the current behavior without compromising the existing supported scenarios and to implement new and shiny features. During this presentation we will explain the present and the plans for the supported installation scenarios, for the partitioning proposal (a.k.a. Guided Setup) and for our beloved Partitioner. We need help from the openSUSE community to review and refine those plans and to bring new ideas to the table. Bring your storage wish list! As many openSUSE users may know, two of the most important YaST components, libstorage and yast2-storage, were recently rewritten from scratch in order to ease the maintenance and to be prepared for whatever the future brings. Now we have a solid base to adapt the current behavior without compromising the existing supported scenarios and to implement new and shiny features. During this presentation we will explain the present and the plans for the supported installation scenarios, for the partitioning proposal (a.k.a. Guided Setup) and for our beloved Partitioner. We need help from the openSUSE community to review and refine those plans and to bring new ideas to the table. Bring your storage wish list! about this event: https://c3voc.de 00:35:48 https://media.ccc.de/v/1900-opensuse-leap-release openSUSE Leap 15 should be ready at the conference. So this "talk" gives a short intro and releases Leap 15 live. openSUSE Leap 15 should be ready at the conference. So this "talk" gives a short intro and releases Leap 15 live. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1900-eng-openSUSE_Leap_Release_hd.mp4?1527351434 hHiF53hxMx3Q6X6kUKc5ow 2018-05-25T00:00:00+02:00 Ludwig Nussel No osc18, 1900 openSUSE Leap 15 should be ready at the conference. So this "talk" gives a short intro and releases Leap 15 live. openSUSE Leap 15 should be ready at the conference. So this "talk" gives a short intro and releases Leap 15 live. about this event: https://c3voc.de 00:15:06 https://media.ccc.de/v/1828-tumbleweed-snapshots-rolling-with-you Tumbleweed, being a rolling distribution, is constantly changing and packages are constantly being rebuilt against one another and updating requirements. As such it becomes necessary to update even when undesirable. For example, one is running snapshot 17 and the next day snapshot 18 contains a QT update that rebuilt a large number of packages. When attempting to install an application that depends on QT one is greeted with an ugly unresolveable error. It is then necessary to run a full update, likely very large with many unrelated changes, in order to simply install an application as would have been possible yesterday. If a remote repository containing historical snapshots was available one could simply install the application and perhaps the handful of new dependencies it requires rather than having to update the entire system. This provides one with the benefits of a rolling distribution without requiring the constant change. A week later when a new kernel and DRM stack provides an exciting feature it is still easy to update everything and be running the latest code, but the user is not interrupted by having to update when it should not be necessary. From another angle, the capabilities of rollback using snapper and btrfs are widely advertised, but the cumbersome and rather unusable state in which a user is left is not commonly discussed. If for example a kernel and/or network manager update completely break network functionality for certain users they can rollback, but then what. As they wait for a fix their installation falls further behind and with that it becomes less and less likely that installing a new package will function properly. On a similar note, if one wanted to install debuginfo packages it is many times impossible without first updating that application and with it many of its dependencies. Such historical snapshot repositories are available and a command line tool, built on libzypp changes, which eases usage. This talk will provide an introduction to the motivation behind this project, implementation, and usage. In addition the Tumbleweed snapshot review site will also be covered to aid users in utilizing Tumbleweed in a manor that suits them. In general this approach offers no downsides if one wishes to still update to every new snapshot or preferred to wait in order to ensure a usable system for getting work done. The review site opens up the possibility to analyze and even predict the stability of releases. With this there is likely plenty of topics of discussion surrounding pushing it further. - https://www.youtube.com/watch?v=CSXRreUjiIc - http://release-tools.opensuse.org/2017/11/22/Tumbleweed-Snapshots.html - http://review.tumbleweed.boombatower.com/ Tumbleweed, being a rolling distribution, is constantly changing and packages are constantly being rebuilt against one another and updating requirements. As such it becomes necessary to update even when undesirable. For example, one is running snapshot 17 and the next day snapshot 18 contains a QT update that rebuilt a large number of packages. When attempting to install an application that depends on QT one is greeted with an ugly unresolveable error. It is then necessary to run a full update, likely very large with many unrelated changes, in order to simply install an application as would have been possible yesterday. If a remote repository containing historical snapshots was available one could simply install the application and perhaps the handful of new dependencies it requires rather than having to update the entire system. This provides one with the benefits of a rolling distribution without requiring the constant change. A week later when a new kernel and DRM stack provides an exciting feature it is still easy to update everything and be running the latest code, but the user is not interrupted by having to update when it should not be necessary. From another angle, the capabilities of rollback using snapper and btrfs are widely advertised, but the cumbersome and rather unusable state in which a user is left is not commonly discussed. If for example a kernel and/or network manager update completely break network functionality for certain users they can rollback, but then what. As they wait for a fix their installation falls further behind and with that it becomes less and less likely that installing a new package will function properly. On a similar note, if one wanted to install debuginfo packages it is many times impossible without first updating that application and with it many of its dependencies. Such historical snapshot repositories are available and a command line tool, built on libzypp changes, which eases usage. This talk will provide an introduction to the motivation behind this project, implementation, and usage. In addition the Tumbleweed snapshot review site will also be covered to aid users in utilizing Tumbleweed in a manor that suits them. In general this approach offers no downsides if one wishes to still update to every new snapshot or preferred to wait in order to ensure a usable system for getting work done. The review site opens up the possibility to analyze and even predict the stability of releases. With this there is likely plenty of topics of discussion surrounding pushing it further. - https://www.youtube.com/watch?v=CSXRreUjiIc - http://release-tools.opensuse.org/2017/11/22/Tumbleweed-Snapshots.html - http://review.tumbleweed.boombatower.com/ about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1828-eng-Tumbleweed_Snapshots_Rolling_With_You_hd.mp4?1527351455 iuQg4QTT4jQjdgW1pXACAA 2018-05-26T00:00:00+02:00 Jimmy Berry No osc18, 1828, openSUSE The missing link between fixed and rolling releases Tumbleweed, being a rolling distribution, is constantly changing and packages are constantly being rebuilt against one another and updating requirements. As such it becomes necessary to update even when undesirable. For example, one is running snapshot 17 and the next day snapshot 18 contains a QT update that rebuilt a large number of packages. When attempting to install an application that depends on QT one is greeted with an ugly unresolveable error. It is then necessary to run a full update, likely very large with many unrelated changes, in order to simply install an application as would have been possible yesterday. If a remote repository containing historical snapshots was available one could simply install the application and perhaps the handful of new dependencies it requires rather than having to update the entire system. This provides one with the benefits of a rolling distribution without requiring the constant change. A week later when a new kernel and DRM stack provides an exciting feature it is still easy to update everything and be running the latest code, but the user is not interrupted by having to update when it should not be necessary. From another angle, the capabilities of rollback using snapper and btrfs are widely advertised, but the cumbersome and rather unusable state in which a user is left is not commonly discussed. If for example a kernel and/or network manager update completely break network functionality for certain users they can rollback, but then what. As they wait for a fix their installation falls further behind and with that it becomes less and less likely that installing a new package will function properly. On a similar note, if one wanted to install debuginfo packages it is many times impossible without first updating that application and with it many of its dependencies. Such historical snapshot repositories are available and a command line tool, built on libzypp changes, which eases usage. This talk will provide an introduction to the motivation behind this project, implementation, and usage. In addition the Tumbleweed snapshot review site will also be covered to aid users in utilizing Tumbleweed in a manor that suits them. In general this approach offers no downsides if one wishes to still update to every new snapshot or preferred to wait in order to ensure a usable system for getting work done. The review site opens up the possibility to analyze and even predict the stability of releases. With this there is likely plenty of topics of discussion surrounding pushing it further. - https://www.youtube.com/watch?v=CSXRreUjiIc - http://release-tools.opensuse.org/2017/11/22/Tumbleweed-Snapshots.html - http://review.tumbleweed.boombatower.com/ Tumbleweed, being a rolling distribution, is constantly changing and packages are constantly being rebuilt against one another and updating requirements. As such it becomes necessary to update even when undesirable. For example, one is running snapshot 17 and the next day snapshot 18 contains a QT update that rebuilt a large number of packages. When attempting to install an application that depends on QT one is greeted with an ugly unresolveable error. It is then necessary to run a full update, likely very large with many unrelated changes, in order to simply install an application as would have been possible yesterday. If a remote repository containing historical snapshots was available one could simply install the application and perhaps the handful of new dependencies it requires rather than having to update the entire system. This provides one with the benefits of a rolling distribution without requiring the constant change. A week later when a new kernel and DRM stack provides an exciting feature it is still easy to update everything and be running the latest code, but the user is not interrupted by having to update when it should not be necessary. From another angle, the capabilities of rollback using snapper and btrfs are widely advertised, but the cumbersome and rather unusable state in which a user is left is not commonly discussed. If for example a kernel and/or network manager update completely break network functionality for certain users they can rollback, but then what. As they wait for a fix their installation falls further behind and with that it becomes less and less likely that installing a new package will function properly. On a similar note, if one wanted to install debuginfo packages it is many times impossible without first updating that application and with it many of its dependencies. Such historical snapshot repositories are available and a command line tool, built on libzypp changes, which eases usage. This talk will provide an introduction to the motivation behind this project, implementation, and usage. In addition the Tumbleweed snapshot review site will also be covered to aid users in utilizing Tumbleweed in a manor that suits them. In general this approach offers no downsides if one wishes to still update to every new snapshot or preferred to wait in order to ensure a usable system for getting work done. The review site opens up the possibility to analyze and even predict the stability of releases. With this there is likely plenty of topics of discussion surrounding pushing it further. - https://www.youtube.com/watch?v=CSXRreUjiIc - http://release-tools.opensuse.org/2017/11/22/Tumbleweed-Snapshots.html - http://review.tumbleweed.boombatower.com/ about this event: https://c3voc.de 00:30:41 https://media.ccc.de/v/1825-introduction-to-tls-1-3 TLS 1.3 is the brand new version of the SSL/TLS protocol. The draft of the standard was recently approved by IETF and it will be published as RFC in a couple of months. TLS 1.3 is a big redesign of the protocol which brings substantial changes such as better security or handshake speed-up. The talk will present its new features as well as compare the new protocol to the previous versions. It will also focus on the status of openSUSE, for example how are the web browsers, common cryptography libraries, and applications doing with regard to the TLS 1.3 support. TLS 1.3 is the brand new version of the SSL/TLS protocol. The draft of the standard was recently approved by IETF and it will be published as RFC in a couple of months. TLS 1.3 is a big redesign of the protocol which brings substantial changes such as better security or handshake speed-up. The talk will present its new features as well as compare the new protocol to the previous versions. It will also focus on the status of openSUSE, for example how are the web browsers, common cryptography libraries, and applications doing with regard to the TLS 1.3 support. about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1825-eng-Introduction_to_TLS_13_hd.mp4?1527341299 qdF7gg_mucGoRsXsKeWS_A 2018-05-26T00:00:00+02:00 vitezslav_cizek No osc18, 1825, Open Source TLS 1.3 is the brand new version of the SSL/TLS protocol. The draft of the standard was recently approved by IETF and it will be published as RFC in a couple of months. TLS 1.3 is a big redesign of the protocol which brings substantial changes such as better security or handshake speed-up. The talk will present its new features as well as compare the new protocol to the previous versions. It will also focus on the status of openSUSE, for example how are the web browsers, common cryptography libraries, and applications doing with regard to the TLS 1.3 support. TLS 1.3 is the brand new version of the SSL/TLS protocol. The draft of the standard was recently approved by IETF and it will be published as RFC in a couple of months. TLS 1.3 is a big redesign of the protocol which brings substantial changes such as better security or handshake speed-up. The talk will present its new features as well as compare the new protocol to the previous versions. It will also focus on the status of openSUSE, for example how are the web browsers, common cryptography libraries, and applications doing with regard to the TLS 1.3 support. about this event: https://c3voc.de 00:49:21 https://media.ccc.de/v/1663-fleet-commander-the-efficient-way-of-managing-the-desktop-profiles-of-your-fleet This talk will go through what Fleet Commander is (and, consequently, what Fleet Commander is not intended for), which are the solutions proposed by the project, how Fleet Commander interacts with SSSD and freeIPA and, plans for the future and finally provide a Demo of the current state of the project. The talk will be divided basically in 4 parts: 1) Describing what Fleet Commander is (and what it's not intended for): Fleet Commander is an integrated solution for large Linux desktop deployments that provides a configuration management interface that is controlled centrally and that covers desktop, applications and network configuration. Last but not least, Neither Ansible nor Puppet could solve the core problems of Desktop Session Configuration Management, which is what drove the Fleet Commander development. 2) Describing Fleet Commander interaction with freeIPA and SSSD: Fleet Commander relies on freeIPA, which provides a standalone plugin for desktop profile management, to store the profile data and its assignments to users, groups and hosts from the administrator point-of-view. From the client point-of-view, Fleet Commander relies on SSSD to fetch the the profile data at users' login time and notify Fleet Commander whenever new profiles have to be applied. 3) A short Demo about the current status of the project: This will be the first time that Fleet Commander project will be Demo'ed after the freeIPA/SSSD integration. 4) Plans for the future: A quick discussion about what are the plans for the future, including a way to manage profile data in case of direct integration between Linux clients and Active Directory servers! This talk will go through what Fleet Commander is (and, consequently, what Fleet Commander is not intended for), which are the solutions proposed by the project, how Fleet Commander interacts with SSSD and freeIPA and, plans for the future and finally provide a Demo of the current state of the project. The talk will be divided basically in 4 parts: 1) Describing what Fleet Commander is (and what it's not intended for): Fleet Commander is an integrated solution for large Linux desktop deployments that provides a configuration management interface that is controlled centrally and that covers desktop, applications and network configuration. Last but not least, Neither Ansible nor Puppet could solve the core problems of Desktop Session Configuration Management, which is what drove the Fleet Commander development. 2) Describing Fleet Commander interaction with freeIPA and SSSD: Fleet Commander relies on freeIPA, which provides a standalone plugin for desktop profile management, to store the profile data and its assignments to users, groups and hosts from the administrator point-of-view. From the client point-of-view, Fleet Commander relies on SSSD to fetch the the profile data at users' login time and notify Fleet Commander whenever new profiles have to be applied. 3) A short Demo about the current status of the project: This will be the first time that Fleet Commander project will be Demo'ed after the freeIPA/SSSD integration. 4) Plans for the future: A quick discussion about what are the plans for the future, including a way to manage profile data in case of direct integration between Linux clients and Active Directory servers! about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1663-eng-Fleet_Commander_The_efficient_way_of_managing_the_Desktop_profiles_of_your_fleet_hd.mp4?1527338831 GmtN-uEY5pV3iXBo4RxuDQ 2018-05-26T00:00:00+02:00 Fabiano Fidêncio No osc18, 1663, Desktop and Applications A brief description of the project and its internals! This talk will go through what Fleet Commander is (and, consequently, what Fleet Commander is not intended for), which are the solutions proposed by the project, how Fleet Commander interacts with SSSD and freeIPA and, plans for the future and finally provide a Demo of the current state of the project. The talk will be divided basically in 4 parts: 1) Describing what Fleet Commander is (and what it's not intended for): Fleet Commander is an integrated solution for large Linux desktop deployments that provides a configuration management interface that is controlled centrally and that covers desktop, applications and network configuration. Last but not least, Neither Ansible nor Puppet could solve the core problems of Desktop Session Configuration Management, which is what drove the Fleet Commander development. 2) Describing Fleet Commander interaction with freeIPA and SSSD: Fleet Commander relies on freeIPA, which provides a standalone plugin for desktop profile management, to store the profile data and its assignments to users, groups and hosts from the administrator point-of-view. From the client point-of-view, Fleet Commander relies on SSSD to fetch the the profile data at users' login time and notify Fleet Commander whenever new profiles have to be applied. 3) A short Demo about the current status of the project: This will be the first time that Fleet Commander project will be Demo'ed after the freeIPA/SSSD integration. 4) Plans for the future: A quick discussion about what are the plans for the future, including a way to manage profile data in case of direct integration between Linux clients and Active Directory servers! This talk will go through what Fleet Commander is (and, consequently, what Fleet Commander is not intended for), which are the solutions proposed by the project, how Fleet Commander interacts with SSSD and freeIPA and, plans for the future and finally provide a Demo of the current state of the project. The talk will be divided basically in 4 parts: 1) Describing what Fleet Commander is (and what it's not intended for): Fleet Commander is an integrated solution for large Linux desktop deployments that provides a configuration management interface that is controlled centrally and that covers desktop, applications and network configuration. Last but not least, Neither Ansible nor Puppet could solve the core problems of Desktop Session Configuration Management, which is what drove the Fleet Commander development. 2) Describing Fleet Commander interaction with freeIPA and SSSD: Fleet Commander relies on freeIPA, which provides a standalone plugin for desktop profile management, to store the profile data and its assignments to users, groups and hosts from the administrator point-of-view. From the client point-of-view, Fleet Commander relies on SSSD to fetch the the profile data at users' login time and notify Fleet Commander whenever new profiles have to be applied. 3) A short Demo about the current status of the project: This will be the first time that Fleet Commander project will be Demo'ed after the freeIPA/SSSD integration. 4) Plans for the future: A quick discussion about what are the plans for the future, including a way to manage profile data in case of direct integration between Linux clients and Active Directory servers! about this event: https://c3voc.de 00:28:27 https://media.ccc.de/v/1849-meet-uyuni-a-complete-opensource-solution-to-keep-multiple-gnu-linux-systems-configured-and-up-to-date Learn an easy way of keeping your systems configured and up-to-date via opensource tooling, even for huge infrastructures. Learn an easy way of keeping your systems configured and up-to-date via opensource tooling, even for huge infrastructures. about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1849-eng-Meet_Uyuni_A_complete_opensource_solution_to_keep_multiple_GNU_Linux_systems_configured_and_up-to-date_hd.mp4?1527334547 22g21-9kzH5VYk6hwXsmlA 2018-05-26T00:00:00+02:00 Julio González Gil No osc18, 1849, Open Source Learn an easy way of keeping your systems configured and up-to-date via opensource tooling, even for huge infrastructures. Learn an easy way of keeping your systems configured and up-to-date via opensource tooling, even for huge infrastructures. about this event: https://c3voc.de 00:24:00 https://media.ccc.de/v/1918-mycroft-a-i-in-the-desktop Mycroft is an open source virtual assistant similar to the ones provided on phones by some companies. It provides some interesting functionality, it's open source, it's easily expanded with new functionality and it's fun. During the last hackweek, I packaged it so it's easy to install on Tumbleweed and in this talk I'll try to show how it works, the changes I did to it in order to package it and maybe how to add a new skill. Mycroft is an open source virtual assistant similar to the ones provided on phones by some companies. It provides some interesting functionality, it's open source, it's easily expanded with new functionality and it's fun. During the last hackweek, I packaged it so it's easy to install on Tumbleweed and in this talk I'll try to show how it works, the changes I did to it in order to package it and maybe how to add a new skill. about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1918-eng-Mycroft_AI_in_the_desktop_hd.mp4?1527334127 rAlGHFVF-3UnW0IhVWOEEQ 2018-05-26T00:00:00+02:00 Antonio Larrosa No osc18, 1918, Desktop and Applications Control your desktop with your voice Mycroft is an open source virtual assistant similar to the ones provided on phones by some companies. It provides some interesting functionality, it's open source, it's easily expanded with new functionality and it's fun. During the last hackweek, I packaged it so it's easy to install on Tumbleweed and in this talk I'll try to show how it works, the changes I did to it in order to package it and maybe how to add a new skill. Mycroft is an open source virtual assistant similar to the ones provided on phones by some companies. It provides some interesting functionality, it's open source, it's easily expanded with new functionality and it's fun. During the last hackweek, I packaged it so it's easy to install on Tumbleweed and in this talk I'll try to show how it works, the changes I did to it in order to package it and maybe how to add a new skill. about this event: https://c3voc.de 00:36:03 https://media.ccc.de/v/1951-security-retrospective-of-the-last-year Last year was a quite busy year on the security front, various big issues happened, so its good to tell what security has done there and is doing for openSUSE and SUSE in general here. The talk will give a brief overview of how the SUSE Security Team works and operates. We will look at the reactive work including statistics, and also look at proactive secure development lifecycle activities. I will also highlight some of the big security issues we faced over the last year. - Stack Clash from mid of 2017. Overview of the problem, what we do for mitigations, and our long way for compiler mitigations. - Meltdown and Spectre As we hoped never to have a StackClash like issue again, CPU sidechannel issues surfaced which needed kernel mitigations begin of January. I will give an overview over what these issues are, and how we mitigated them or are still mitigating them. I will also talk about one of my projects done in the last year: - Full PIE enablement for the distribution and its long road to Factory. Last year was a quite busy year on the security front, various big issues happened, so its good to tell what security has done there and is doing for openSUSE and SUSE in general here. The talk will give a brief overview of how the SUSE Security Team works and operates. We will look at the reactive work including statistics, and also look at proactive secure development lifecycle activities. I will also highlight some of the big security issues we faced over the last year. - Stack Clash from mid of 2017. Overview of the problem, what we do for mitigations, and our long way for compiler mitigations. - Meltdown and Spectre As we hoped never to have a StackClash like issue again, CPU sidechannel issues surfaced which needed kernel mitigations begin of January. I will give an overview over what these issues are, and how we mitigated them or are still mitigating them. I will also talk about one of my projects done in the last year: - Full PIE enablement for the distribution and its long road to Factory. about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1951-eng-Security_Retrospective_of_the_last_year_hd.mp4?1527334006 Zl3dhPdZJyFIkpiNIqHhhQ 2018-05-26T00:00:00+02:00 Marcus Meissner No osc18, 1951, Open Source Not just Meltdown and Spectre Last year was a quite busy year on the security front, various big issues happened, so its good to tell what security has done there and is doing for openSUSE and SUSE in general here. The talk will give a brief overview of how the SUSE Security Team works and operates. We will look at the reactive work including statistics, and also look at proactive secure development lifecycle activities. I will also highlight some of the big security issues we faced over the last year. - Stack Clash from mid of 2017. Overview of the problem, what we do for mitigations, and our long way for compiler mitigations. - Meltdown and Spectre As we hoped never to have a StackClash like issue again, CPU sidechannel issues surfaced which needed kernel mitigations begin of January. I will give an overview over what these issues are, and how we mitigated them or are still mitigating them. I will also talk about one of my projects done in the last year: - Full PIE enablement for the distribution and its long road to Factory. Last year was a quite busy year on the security front, various big issues happened, so its good to tell what security has done there and is doing for openSUSE and SUSE in general here. The talk will give a brief overview of how the SUSE Security Team works and operates. We will look at the reactive work including statistics, and also look at proactive secure development lifecycle activities. I will also highlight some of the big security issues we faced over the last year. - Stack Clash from mid of 2017. Overview of the problem, what we do for mitigations, and our long way for compiler mitigations. - Meltdown and Spectre As we hoped never to have a StackClash like issue again, CPU sidechannel issues surfaced which needed kernel mitigations begin of January. I will give an overview over what these issues are, and how we mitigated them or are still mitigating them. I will also talk about one of my projects done in the last year: - Full PIE enablement for the distribution and its long road to Factory. about this event: https://c3voc.de 00:44:47 https://media.ccc.de/v/1936-making-the-lsm-available-to-containers Containers would like to be able to make use of Linux Security Modules (LSMs), from providing more complete system virtualization to improving container confinement. To date containers access to the LSM has been limited but there has been work to change the situation. This presentation will discuss the current state of LSM stacking and namespacing. The work being done on various security modules to support namespacing, the infrastructure work being done to improve the LSM, an examination of the remaining problems, and provide a demo of a container leveraging LSM stacking so that the host is using a different security module than that of the container. Containers would like to be able to make use of Linux Security Modules (LSMs), from providing more complete system virtualization to improving container confinement. To date containers access to the LSM has been limited but there has been work to change the situation. This presentation will discuss the current state of LSM stacking and namespacing. The work being done on various security modules to support namespacing, the infrastructure work being done to improve the LSM, an examination of the remaining problems, and provide a demo of a container leveraging LSM stacking so that the host is using a different security module than that of the container. about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1936-eng-Making_the_LSM_available_to_containers_hd.mp4?1527333494 wpBKBgkKZy0zmwWeSZK19A 2018-05-26T00:00:00+02:00 John Johansen No osc18, 1936, Open Source stacking and namespacing the LSM Containers would like to be able to make use of Linux Security Modules (LSMs), from providing more complete system virtualization to improving container confinement. To date containers access to the LSM has been limited but there has been work to change the situation. This presentation will discuss the current state of LSM stacking and namespacing. The work being done on various security modules to support namespacing, the infrastructure work being done to improve the LSM, an examination of the remaining problems, and provide a demo of a container leveraging LSM stacking so that the host is using a different security module than that of the container. Containers would like to be able to make use of Linux Security Modules (LSMs), from providing more complete system virtualization to improving container confinement. To date containers access to the LSM has been limited but there has been work to change the situation. This presentation will discuss the current state of LSM stacking and namespacing. The work being done on various security modules to support namespacing, the infrastructure work being done to improve the LSM, an examination of the remaining problems, and provide a demo of a container leveraging LSM stacking so that the host is using a different security module than that of the container. about this event: https://c3voc.de 00:28:09 https://media.ccc.de/v/1702-the-gnu-health-free-software-technology-improving-public-healthcare-around-the-world GNU Health is a social project that provides a community-based, Free/Libre Health and Hospital Information System deployed in many countries around the globe. GNU Health combines Social Medicine and Primary healthcare principles with state of the art advances in bioinformatics and precision medicine, delivering a valuable framework for governments and Public Health institutions, as well as for academic and research organizations. In this presentation we will go through some of the existing and upcoming technologies behind GNU Health and their use in different scenarios. The GNU Health Federation to integrate large, heterogeneous health and research networks; The integration with OpenStreetMaps and the mobile application will be some of the topics. Finally, we will present the GNU Health embedded project, a joint effort with OpenSUSE, to use GNU Health in single-board devices such as the Raspberry Pi. We will go through the many benefits that this project brings to communities around the world, delivering Freedom and Equity in Healthcare, which is our ultimate goal. GNU Health is a social project that provides a community-based, Free/Libre Health and Hospital Information System deployed in many countries around the globe. GNU Health combines Social Medicine and Primary healthcare principles with state of the art advances in bioinformatics and precision medicine, delivering a valuable framework for governments and Public Health institutions, as well as for academic and research organizations. In this presentation we will go through some of the existing and upcoming technologies behind GNU Health and their use in different scenarios. The GNU Health Federation to integrate large, heterogeneous health and research networks; The integration with OpenStreetMaps and the mobile application will be some of the topics. Finally, we will present the GNU Health embedded project, a joint effort with OpenSUSE, to use GNU Health in single-board devices such as the Raspberry Pi. We will go through the many benefits that this project brings to communities around the world, delivering Freedom and Equity in Healthcare, which is our ultimate goal. about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1702-eng-The_GNU_Health_Free_Software_technology_improving_Public_Healthcare_around_the_world_hd.mp4?1527333253 WnUprZFOjGuyVTwXu1V-aQ 2018-05-26T00:00:00+02:00 Luis Falcon No osc18, 1702, Open Source GNU Health uses Free/Libre, state-of-the-art technology to deliver Freedom and Equity in Healthcare GNU Health is a social project that provides a community-based, Free/Libre Health and Hospital Information System deployed in many countries around the globe. GNU Health combines Social Medicine and Primary healthcare principles with state of the art advances in bioinformatics and precision medicine, delivering a valuable framework for governments and Public Health institutions, as well as for academic and research organizations. In this presentation we will go through some of the existing and upcoming technologies behind GNU Health and their use in different scenarios. The GNU Health Federation to integrate large, heterogeneous health and research networks; The integration with OpenStreetMaps and the mobile application will be some of the topics. Finally, we will present the GNU Health embedded project, a joint effort with OpenSUSE, to use GNU Health in single-board devices such as the Raspberry Pi. We will go through the many benefits that this project brings to communities around the world, delivering Freedom and Equity in Healthcare, which is our ultimate goal. GNU Health is a social project that provides a community-based, Free/Libre Health and Hospital Information System deployed in many countries around the globe. GNU Health combines Social Medicine and Primary healthcare principles with state of the art advances in bioinformatics and precision medicine, delivering a valuable framework for governments and Public Health institutions, as well as for academic and research organizations. In this presentation we will go through some of the existing and upcoming technologies behind GNU Health and their use in different scenarios. The GNU Health Federation to integrate large, heterogeneous health and research networks; The integration with OpenStreetMaps and the mobile application will be some of the topics. Finally, we will present the GNU Health embedded project, a joint effort with OpenSUSE, to use GNU Health in single-board devices such as the Raspberry Pi. We will go through the many benefits that this project brings to communities around the world, delivering Freedom and Equity in Healthcare, which is our ultimate goal. about this event: https://c3voc.de 00:33:06 https://media.ccc.de/v/1708-gnu-health-on-opensuse-a-community-view GNU Health is a community driven project. There is a wide spread variety of users that run GNU Health in different scenarios. And there is a community of 'makers', that build the software and brings it to its users. This presentation will put some light into both communities. For the first time we have collected the end users, and will present some statistics around that. And for you, the maker community, we will give you some ideas whats next in the development pipeline GNU Health is a community driven project. There is a wide spread variety of users that run GNU Health in different scenarios. And there is a community of 'makers', that build the software and brings it to its users. This presentation will put some light into both communities. For the first time we have collected the end users, and will present some statistics around that. And for you, the maker community, we will give you some ideas whats next in the development pipeline about this event: https://c3voc.de Sat, 26 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1708-eng-GNU_Health_on_openSUSE_-_a_community_view_hd.mp4?1527332333 Kx8dFiGvYI8IYz4byF2Tsw 2018-05-26T00:00:00+02:00 Axel Braun No osc18, 1708, openSUSE Insights into a global, diverse and friendly community GNU Health is a community driven project. There is a wide spread variety of users that run GNU Health in different scenarios. And there is a community of 'makers', that build the software and brings it to its users. This presentation will put some light into both communities. For the first time we have collected the end users, and will present some statistics around that. And for you, the maker community, we will give you some ideas whats next in the development pipeline GNU Health is a community driven project. There is a wide spread variety of users that run GNU Health in different scenarios. And there is a community of 'makers', that build the software and brings it to its users. This presentation will put some light into both communities. For the first time we have collected the end users, and will present some statistics around that. And for you, the maker community, we will give you some ideas whats next in the development pipeline about this event: https://c3voc.de 00:50:42 https://media.ccc.de/v/1846-building-opensuse-with-gcc-s-link-time-optimization Link time optimization (LTO) extends scope of compiler optimizations to whole program or DSO. We present some data on pros & cons of using LTO to build openSUSE distribution by default. This is joint with with Martin Liška and Martin Jambor. Link time optimization (LTO) extends scope of compiler optimizations to whole program or DSO. We present some data on pros & cons of using LTO to build openSUSE distribution by default. This is joint with with Martin Liška and Martin Jambor. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1846-eng-building_openSUSE_with_GCCs_link_time_optimization_hd.mp4?1527272930 xgeracUcSNLdmofWET4R6A 2018-05-25T00:00:00+02:00 Jan Hubička No osc18, 1846, openSUSE smaller & faster binaries Link time optimization (LTO) extends scope of compiler optimizations to whole program or DSO. We present some data on pros & cons of using LTO to build openSUSE distribution by default. This is joint with with Martin Liška and Martin Jambor. Link time optimization (LTO) extends scope of compiler optimizations to whole program or DSO. We present some data on pros & cons of using LTO to build openSUSE distribution by default. This is joint with with Martin Liška and Martin Jambor. about this event: https://c3voc.de 00:39:19 https://media.ccc.de/v/1909-atomic-bonds-opensuse-kubic-suse-caasp The Kubic Project is an exciting new part of the openSUSE family. This talk will provide a brief introduction of the Project and how it focuses on container technologies such as the Docker & Podman runtimes, Kubernetes, Transactional (Atomic) Operating System updates, and much more. The session will then go into detail how Kubic provides the base for SUSE's Container as a Service Platform (CaaSP), explaining how Kubic serves a similar role to that product as Tumbleweed does to SUSE Linux Enterprise, and explaining the relationship between CaaSP versions, SLE versions, and Tumbleweed. Finally, this presentation will be an opportunity for those interested in Kubic to learn ways they can get involved with the project and contribute, regardless if their interest is containers, orchestration, testing, or atomic system updates. The Kubic Project is an exciting new part of the openSUSE family. This talk will provide a brief introduction of the Project and how it focuses on container technologies such as the Docker & Podman runtimes, Kubernetes, Transactional (Atomic) Operating System updates, and much more. The session will then go into detail how Kubic provides the base for SUSE's Container as a Service Platform (CaaSP), explaining how Kubic serves a similar role to that product as Tumbleweed does to SUSE Linux Enterprise, and explaining the relationship between CaaSP versions, SLE versions, and Tumbleweed. Finally, this presentation will be an opportunity for those interested in Kubic to learn ways they can get involved with the project and contribute, regardless if their interest is containers, orchestration, testing, or atomic system updates. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1909-eng-Atomic_Bonds_openSUSE_Kubic_SUSE_CaaSP_hd.mp4?1527272872 MvjuM5ztxLYRNqCdWCtUWQ 2018-05-25T00:00:00+02:00 Richard Brown No osc18, 1909, Cloud and Containers openSUSE & SUSE exploring the container world The Kubic Project is an exciting new part of the openSUSE family. This talk will provide a brief introduction of the Project and how it focuses on container technologies such as the Docker & Podman runtimes, Kubernetes, Transactional (Atomic) Operating System updates, and much more. The session will then go into detail how Kubic provides the base for SUSE's Container as a Service Platform (CaaSP), explaining how Kubic serves a similar role to that product as Tumbleweed does to SUSE Linux Enterprise, and explaining the relationship between CaaSP versions, SLE versions, and Tumbleweed. Finally, this presentation will be an opportunity for those interested in Kubic to learn ways they can get involved with the project and contribute, regardless if their interest is containers, orchestration, testing, or atomic system updates. The Kubic Project is an exciting new part of the openSUSE family. This talk will provide a brief introduction of the Project and how it focuses on container technologies such as the Docker & Podman runtimes, Kubernetes, Transactional (Atomic) Operating System updates, and much more. The session will then go into detail how Kubic provides the base for SUSE's Container as a Service Platform (CaaSP), explaining how Kubic serves a similar role to that product as Tumbleweed does to SUSE Linux Enterprise, and explaining the relationship between CaaSP versions, SLE versions, and Tumbleweed. Finally, this presentation will be an opportunity for those interested in Kubic to learn ways they can get involved with the project and contribute, regardless if their interest is containers, orchestration, testing, or atomic system updates. about this event: https://c3voc.de 00:36:07 https://media.ccc.de/v/1687-osc-what-s-new-and-best-practices Many of us use osc on a daily base. This talk will be about new features in osc, plugins and best practices. At the end I will provide a small outlook what new features are planned. Many of us use osc on a daily base. This talk will be about new features in osc, plugins and best practices. At the end I will provide a small outlook what new features are planned. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1687-eng-osc_-_Whats_new_and_best_practices_hd.mp4?1527272836 EkYaWq2fVyj_MEV2gO0O0w 2018-05-25T00:00:00+02:00 Marco Strigl No osc18, 1687, openSUSE Things you may have missed Many of us use osc on a daily base. This talk will be about new features in osc, plugins and best practices. At the end I will provide a small outlook what new features are planned. Many of us use osc on a daily base. This talk will be about new features in osc, plugins and best practices. At the end I will provide a small outlook what new features are planned. about this event: https://c3voc.de 00:36:14 https://media.ccc.de/v/1882-managing-opensuse-with-saltstack Systems management in the era of containerization and hybrid clouds can challenge even the most seasoned professional. In this session, we'll learn how to control the chaos by bringing disciplined automation practices to the rescue. Presented by the principal maintainer of the SaltStack project -- one of the largest and most active open-source communities in the world -- we'll learn how to use Salt manage everything from the smallest embedded systems to some of the largest computing infrastructures in the world. By the time this session is complete, attendees will be armed with practical information about how to deploy Salt's automation framework which can be used right away to immediately begin to order to chaotic environments. We'll spend time focusing especially on features which can be used to manage SUSE systems but we'll also cover using Salt to manage a variety of deployments including IoT, containers, and legacy infrastructure. Presented by Mike Place, who manages the project full-time, this talk will give attendees a chance to meet the maintainer and talk directly about future plans for the project as well as ask questions about its current direction. We'll talk about where automation is working well in modern computing and where things can be improved. Finally, we'll have a chance to talk about best practices for automation and learn about how its used by some of the best and brightest teams to build and manage systems that anyone could be proud of. Systems management in the era of containerization and hybrid clouds can challenge even the most seasoned professional. In this session, we'll learn how to control the chaos by bringing disciplined automation practices to the rescue. Presented by the principal maintainer of the SaltStack project -- one of the largest and most active open-source communities in the world -- we'll learn how to use Salt manage everything from the smallest embedded systems to some of the largest computing infrastructures in the world. By the time this session is complete, attendees will be armed with practical information about how to deploy Salt's automation framework which can be used right away to immediately begin to order to chaotic environments. We'll spend time focusing especially on features which can be used to manage SUSE systems but we'll also cover using Salt to manage a variety of deployments including IoT, containers, and legacy infrastructure. Presented by Mike Place, who manages the project full-time, this talk will give attendees a chance to meet the maintainer and talk directly about future plans for the project as well as ask questions about its current direction. We'll talk about where automation is working well in modern computing and where things can be improved. Finally, we'll have a chance to talk about best practices for automation and learn about how its used by some of the best and brightest teams to build and manage systems that anyone could be proud of. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1882-eng-Managing_OpenSUSE_with_SaltStack_hd.mp4?1527272806 zEzmm-y7I968cZsdjfWOIA 2018-05-25T00:00:00+02:00 Mike Place No osc18, 1882, Cloud and Containers Controlling Chaos with Event-Driven Automation Systems management in the era of containerization and hybrid clouds can challenge even the most seasoned professional. In this session, we'll learn how to control the chaos by bringing disciplined automation practices to the rescue. Presented by the principal maintainer of the SaltStack project -- one of the largest and most active open-source communities in the world -- we'll learn how to use Salt manage everything from the smallest embedded systems to some of the largest computing infrastructures in the world. By the time this session is complete, attendees will be armed with practical information about how to deploy Salt's automation framework which can be used right away to immediately begin to order to chaotic environments. We'll spend time focusing especially on features which can be used to manage SUSE systems but we'll also cover using Salt to manage a variety of deployments including IoT, containers, and legacy infrastructure. Presented by Mike Place, who manages the project full-time, this talk will give attendees a chance to meet the maintainer and talk directly about future plans for the project as well as ask questions about its current direction. We'll talk about where automation is working well in modern computing and where things can be improved. Finally, we'll have a chance to talk about best practices for automation and learn about how its used by some of the best and brightest teams to build and manage systems that anyone could be proud of. Systems management in the era of containerization and hybrid clouds can challenge even the most seasoned professional. In this session, we'll learn how to control the chaos by bringing disciplined automation practices to the rescue. Presented by the principal maintainer of the SaltStack project -- one of the largest and most active open-source communities in the world -- we'll learn how to use Salt manage everything from the smallest embedded systems to some of the largest computing infrastructures in the world. By the time this session is complete, attendees will be armed with practical information about how to deploy Salt's automation framework which can be used right away to immediately begin to order to chaotic environments. We'll spend time focusing especially on features which can be used to manage SUSE systems but we'll also cover using Salt to manage a variety of deployments including IoT, containers, and legacy infrastructure. Presented by Mike Place, who manages the project full-time, this talk will give attendees a chance to meet the maintainer and talk directly about future plans for the project as well as ask questions about its current direction. We'll talk about where automation is working well in modern computing and where things can be improved. Finally, we'll have a chance to talk about best practices for automation and learn about how its used by some of the best and brightest teams to build and manage systems that anyone could be proud of. about this event: https://c3voc.de 00:33:46 https://media.ccc.de/v/1789-kexec-kdump-under-the-hood Kdump is a vital tool for debugging severe kernel crashes, especially if the failure can't be reproduced easily or an direct access to the system is not possible. When an sever error happens in the kernel, a new crash kernel get loaded which saves the memory of the crashed system. These dump can be used to analyze the state of the machine and hopefully give insights on what has happened. This talks will dive into the internals of kexec and kdump. How the crash kernel get set-up, how it's execution get triggered. We will also look into kexec-tool, the user-space part needed to set up a system to use kdump. Where necessary, the architectural specific details will be explained by looking at the arm64 implementation. This talk is thought for people who want to have an insight into how kdump is working. Kdump is a vital tool for debugging severe kernel crashes, especially if the failure can't be reproduced easily or an direct access to the system is not possible. When an sever error happens in the kernel, a new crash kernel get loaded which saves the memory of the crashed system. These dump can be used to analyze the state of the machine and hopefully give insights on what has happened. This talks will dive into the internals of kexec and kdump. How the crash kernel get set-up, how it's execution get triggered. We will also look into kexec-tool, the user-space part needed to set up a system to use kdump. Where necessary, the architectural specific details will be explained by looking at the arm64 implementation. This talk is thought for people who want to have an insight into how kdump is working. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1789-eng-Kexec_Kdump_under_the_hood_hd.mp4?1527272779 lmZqYJ2kRNjkGHrCQ_EqRw 2018-05-25T00:00:00+02:00 Matthias Brugger No osc18, 1789, Open Source A look on the internals on arm64 Kdump is a vital tool for debugging severe kernel crashes, especially if the failure can't be reproduced easily or an direct access to the system is not possible. When an sever error happens in the kernel, a new crash kernel get loaded which saves the memory of the crashed system. These dump can be used to analyze the state of the machine and hopefully give insights on what has happened. This talks will dive into the internals of kexec and kdump. How the crash kernel get set-up, how it's execution get triggered. We will also look into kexec-tool, the user-space part needed to set up a system to use kdump. Where necessary, the architectural specific details will be explained by looking at the arm64 implementation. This talk is thought for people who want to have an insight into how kdump is working. Kdump is a vital tool for debugging severe kernel crashes, especially if the failure can't be reproduced easily or an direct access to the system is not possible. When an sever error happens in the kernel, a new crash kernel get loaded which saves the memory of the crashed system. These dump can be used to analyze the state of the machine and hopefully give insights on what has happened. This talks will dive into the internals of kexec and kdump. How the crash kernel get set-up, how it's execution get triggered. We will also look into kexec-tool, the user-space part needed to set up a system to use kdump. Where necessary, the architectural specific details will be explained by looking at the arm64 implementation. This talk is thought for people who want to have an insight into how kdump is working. about this event: https://c3voc.de 00:42:45 https://media.ccc.de/v/1843-logging-containers Event logging is a central source of information for IT operations and security. The syslog-ng application collects logs from many different sources, performs real-time log analysis by processing and filtering them, and finally it stores the logs or forwards them for further analysis. The same feature set comes in handy in a containerized environment too, where you start and stop containers around the clock, and the container might not even exist anymore by the time you investigate an event.. Containerization, and Docker in particular, changed the way we distribute and run applications. Containers provide isolated environments, which make it possible to run applications with conflicting dependencies on the same host. There are even dedicated container hosts, like Kubic or SUSE CaaS, which do not allow you to install any applications on the host directly, only in containers. You can install your central syslog-ng server in a container and enjoy all benefits of containerization. You can also use syslog-ng for collecting Docker logs. Docker already provides many drivers for logging, even for central log collection. On the other hand, remote logging drivers arrive with a minimalist feature set and you are not able to use the “docker logs” command anymore. To have the best of both worlds, you can use the journald logging driver in Docker, and use syslog-ng to read Docker logs from journald and to forward log messages to your central log server or other destinations. There are many software that log to files or pipes instead of their stdout, the place where Docker expects them. Fortunately, by using Docker volumes, you can share data among containers, and syslog-ng can collect these logs as well. The use of the wildcard-file source gives you additional flexibility. These look like three separate use cases, but you can freely combine any of these and utilize many more syslog-ng features, like message parsing and enrichment or Big Data destinations. I help you to get started with any of these by giving a quick introduction to the configuration of syslog-ng and showing example Docker command lines as well. By the end of my talk, you should be ready to deploy syslog-ng in Docker and create a simple syslog-ng configuration. Event logging is a central source of information for IT operations and security. The syslog-ng application collects logs from many different sources, performs real-time log analysis by processing and filtering them, and finally it stores the logs or forwards them for further analysis. The same feature set comes in handy in a containerized environment too, where you start and stop containers around the clock, and the container might not even exist anymore by the time you investigate an event.. Containerization, and Docker in particular, changed the way we distribute and run applications. Containers provide isolated environments, which make it possible to run applications with conflicting dependencies on the same host. There are even dedicated container hosts, like Kubic or SUSE CaaS, which do not allow you to install any applications on the host directly, only in containers. You can install your central syslog-ng server in a container and enjoy all benefits of containerization. You can also use syslog-ng for collecting Docker logs. Docker already provides many drivers for logging, even for central log collection. On the other hand, remote logging drivers arrive with a minimalist feature set and you are not able to use the “docker logs” command anymore. To have the best of both worlds, you can use the journald logging driver in Docker, and use syslog-ng to read Docker logs from journald and to forward log messages to your central log server or other destinations. There are many software that log to files or pipes instead of their stdout, the place where Docker expects them. Fortunately, by using Docker volumes, you can share data among containers, and syslog-ng can collect these logs as well. The use of the wildcard-file source gives you additional flexibility. These look like three separate use cases, but you can freely combine any of these and utilize many more syslog-ng features, like message parsing and enrichment or Big Data destinations. I help you to get started with any of these by giving a quick introduction to the configuration of syslog-ng and showing example Docker command lines as well. By the end of my talk, you should be ready to deploy syslog-ng in Docker and create a simple syslog-ng configuration. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1843-eng-Logging_containers_hd.mp4?1527272747 4o9nYvhcvCMqkSmgEzXefQ 2018-05-25T00:00:00+02:00 Peter Czanik No osc18, 1843, Cloud and Containers Collecting host, docker and container logs centrally Event logging is a central source of information for IT operations and security. The syslog-ng application collects logs from many different sources, performs real-time log analysis by processing and filtering them, and finally it stores the logs or forwards them for further analysis. The same feature set comes in handy in a containerized environment too, where you start and stop containers around the clock, and the container might not even exist anymore by the time you investigate an event.. Containerization, and Docker in particular, changed the way we distribute and run applications. Containers provide isolated environments, which make it possible to run applications with conflicting dependencies on the same host. There are even dedicated container hosts, like Kubic or SUSE CaaS, which do not allow you to install any applications on the host directly, only in containers. You can install your central syslog-ng server in a container and enjoy all benefits of containerization. You can also use syslog-ng for collecting Docker logs. Docker already provides many drivers for logging, even for central log collection. On the other hand, remote logging drivers arrive with a minimalist feature set and you are not able to use the “docker logs” command anymore. To have the best of both worlds, you can use the journald logging driver in Docker, and use syslog-ng to read Docker logs from journald and to forward log messages to your central log server or other destinations. There are many software that log to files or pipes instead of their stdout, the place where Docker expects them. Fortunately, by using Docker volumes, you can share data among containers, and syslog-ng can collect these logs as well. The use of the wildcard-file source gives you additional flexibility. These look like three separate use cases, but you can freely combine any of these and utilize many more syslog-ng features, like message parsing and enrichment or Big Data destinations. I help you to get started with any of these by giving a quick introduction to the configuration of syslog-ng and showing example Docker command lines as well. By the end of my talk, you should be ready to deploy syslog-ng in Docker and create a simple syslog-ng configuration. Event logging is a central source of information for IT operations and security. The syslog-ng application collects logs from many different sources, performs real-time log analysis by processing and filtering them, and finally it stores the logs or forwards them for further analysis. The same feature set comes in handy in a containerized environment too, where you start and stop containers around the clock, and the container might not even exist anymore by the time you investigate an event.. Containerization, and Docker in particular, changed the way we distribute and run applications. Containers provide isolated environments, which make it possible to run applications with conflicting dependencies on the same host. There are even dedicated container hosts, like Kubic or SUSE CaaS, which do not allow you to install any applications on the host directly, only in containers. You can install your central syslog-ng server in a container and enjoy all benefits of containerization. You can also use syslog-ng for collecting Docker logs. Docker already provides many drivers for logging, even for central log collection. On the other hand, remote logging drivers arrive with a minimalist feature set and you are not able to use the “docker logs” command anymore. To have the best of both worlds, you can use the journald logging driver in Docker, and use syslog-ng to read Docker logs from journald and to forward log messages to your central log server or other destinations. There are many software that log to files or pipes instead of their stdout, the place where Docker expects them. Fortunately, by using Docker volumes, you can share data among containers, and syslog-ng can collect these logs as well. The use of the wildcard-file source gives you additional flexibility. These look like three separate use cases, but you can freely combine any of these and utilize many more syslog-ng features, like message parsing and enrichment or Big Data destinations. I help you to get started with any of these by giving a quick introduction to the configuration of syslog-ng and showing example Docker command lines as well. By the end of my talk, you should be ready to deploy syslog-ng in Docker and create a simple syslog-ng configuration. about this event: https://c3voc.de 00:36:13 https://media.ccc.de/v/1813-ceph-manager-dashboard The original Ceph Manager Dashboard that was introduced in Ceph "Luminous" started out as a simple, read-only view into various run-time information and performance data of a Ceph cluster, without authentication or any administrative functionality. However, as it turns out, there is a growing demand for adding more web-based management capabilities, to make it easier for administrators that prefer a WebUI to manage Ceph over the command line. After learning about this, we - the openATTIC team - approached upstream and offered our help to implement the missing functionality. Based on our experiences in developing the Ceph support in openATTIC, we think we have a lot to offer in the form of code and experience in creating a Ceph administration and monitoring UI. We already reached feature parity and replaced the existing dashboard mgr module and we're moving forward. If you want to learn more about it this is the right talk for you. The original Ceph Manager Dashboard that was introduced in Ceph "Luminous" started out as a simple, read-only view into various run-time information and performance data of a Ceph cluster, without authentication or any administrative functionality. However, as it turns out, there is a growing demand for adding more web-based management capabilities, to make it easier for administrators that prefer a WebUI to manage Ceph over the command line. After learning about this, we - the openATTIC team - approached upstream and offered our help to implement the missing functionality. Based on our experiences in developing the Ceph support in openATTIC, we think we have a lot to offer in the form of code and experience in creating a Ceph administration and monitoring UI. We already reached feature parity and replaced the existing dashboard mgr module and we're moving forward. If you want to learn more about it this is the right talk for you. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1813-eng-Ceph_Manager_Dashboard_hd.mp4?1527272715 jcy3frAijF580XmQVQvo_w 2018-05-25T00:00:00+02:00 Kai Wagner, Laura Paduano No osc18, 1813, Open Source How do I manage such a big cluster? The original Ceph Manager Dashboard that was introduced in Ceph "Luminous" started out as a simple, read-only view into various run-time information and performance data of a Ceph cluster, without authentication or any administrative functionality. However, as it turns out, there is a growing demand for adding more web-based management capabilities, to make it easier for administrators that prefer a WebUI to manage Ceph over the command line. After learning about this, we - the openATTIC team - approached upstream and offered our help to implement the missing functionality. Based on our experiences in developing the Ceph support in openATTIC, we think we have a lot to offer in the form of code and experience in creating a Ceph administration and monitoring UI. We already reached feature parity and replaced the existing dashboard mgr module and we're moving forward. If you want to learn more about it this is the right talk for you. The original Ceph Manager Dashboard that was introduced in Ceph "Luminous" started out as a simple, read-only view into various run-time information and performance data of a Ceph cluster, without authentication or any administrative functionality. However, as it turns out, there is a growing demand for adding more web-based management capabilities, to make it easier for administrators that prefer a WebUI to manage Ceph over the command line. After learning about this, we - the openATTIC team - approached upstream and offered our help to implement the missing functionality. Based on our experiences in developing the Ceph support in openATTIC, we think we have a lot to offer in the form of code and experience in creating a Ceph administration and monitoring UI. We already reached feature parity and replaced the existing dashboard mgr module and we're moving forward. If you want to learn more about it this is the right talk for you. about this event: https://c3voc.de 00:33:14 https://media.ccc.de/v/1912-opensuse-is-what-you-make-it This talk is for openSUSE's aspiring new contributors, existing contributors, users, detractors, or just anyone curious at all about openSUSE. In other words, if you're at this conference, you should consider being at this talk ;) The session will detail how openSUSE does what it does, and most importantly how openSUSE strives to empower ANYONE to be able to contribute to the project. The presentation will outline examples of not only basic contributions to the distributions (Leap & Tumbleweed), but also explain through example and anecdote how anyone can influence, steer, and drive the direction of the openSUSE Project, including changing the scope of the Project by introducing new sub projects. The session will end with a Q&A section for anyone to ask any question about contributing to the project in general, to provide feedback on any potential improvements to openSUSE's current contribution story, or to ask those first questions about that first contribution so that YOU can start making openSUSE YOURS. This talk is for openSUSE's aspiring new contributors, existing contributors, users, detractors, or just anyone curious at all about openSUSE. In other words, if you're at this conference, you should consider being at this talk ;) The session will detail how openSUSE does what it does, and most importantly how openSUSE strives to empower ANYONE to be able to contribute to the project. The presentation will outline examples of not only basic contributions to the distributions (Leap & Tumbleweed), but also explain through example and anecdote how anyone can influence, steer, and drive the direction of the openSUSE Project, including changing the scope of the Project by introducing new sub projects. The session will end with a Q&A section for anyone to ask any question about contributing to the project in general, to provide feedback on any potential improvements to openSUSE's current contribution story, or to ask those first questions about that first contribution so that YOU can start making openSUSE YOURS. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1912-eng-openSUSE_is_what_you_make_it_hd.mp4?1527272688 uQfyGJHP24cTJ6tMfcefbA 2018-05-25T00:00:00+02:00 Richard Brown No osc18, 1912, openSUSE How to change anything you want in the project This talk is for openSUSE's aspiring new contributors, existing contributors, users, detractors, or just anyone curious at all about openSUSE. In other words, if you're at this conference, you should consider being at this talk ;) The session will detail how openSUSE does what it does, and most importantly how openSUSE strives to empower ANYONE to be able to contribute to the project. The presentation will outline examples of not only basic contributions to the distributions (Leap & Tumbleweed), but also explain through example and anecdote how anyone can influence, steer, and drive the direction of the openSUSE Project, including changing the scope of the Project by introducing new sub projects. The session will end with a Q&A section for anyone to ask any question about contributing to the project in general, to provide feedback on any potential improvements to openSUSE's current contribution story, or to ask those first questions about that first contribution so that YOU can start making openSUSE YOURS. This talk is for openSUSE's aspiring new contributors, existing contributors, users, detractors, or just anyone curious at all about openSUSE. In other words, if you're at this conference, you should consider being at this talk ;) The session will detail how openSUSE does what it does, and most importantly how openSUSE strives to empower ANYONE to be able to contribute to the project. The presentation will outline examples of not only basic contributions to the distributions (Leap & Tumbleweed), but also explain through example and anecdote how anyone can influence, steer, and drive the direction of the openSUSE Project, including changing the scope of the Project by introducing new sub projects. The session will end with a Q&A section for anyone to ask any question about contributing to the project in general, to provide feedback on any potential improvements to openSUSE's current contribution story, or to ask those first questions about that first contribution so that YOU can start making openSUSE YOURS. about this event: https://c3voc.de 00:38:11 https://media.ccc.de/v/1864-package-supplements "Supplements" in packaging seems like a feature that many people are unaware of, this lightning talk aims to make people aware that supplements exist in packaging as well as how and where they should use them. "Supplements" in packaging seems like a feature that many people are unaware of, this lightning talk aims to make people aware that supplements exist in packaging as well as how and where they should use them. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1864-eng-Package_Supplements_hd.mp4?1527272653 OpbFZH8nILNtC6eaVjTKIQ 2018-05-25T00:00:00+02:00 Simon Lees No osc18, 1864, openSUSE "Supplements" in packaging seems like a feature that many people are unaware of, this lightning talk aims to make people aware that supplements exist in packaging as well as how and where they should use them. "Supplements" in packaging seems like a feature that many people are unaware of, this lightning talk aims to make people aware that supplements exist in packaging as well as how and where they should use them. about this event: https://c3voc.de 00:06:45 https://media.ccc.de/v/1903-cloud-from-scratch Driven by curiosity and some late night ebay purchases, I ended up down the rabbit hole of building a cloud from scratch: why use OpenStack when you can do it the hard way. This was a great excuse to dive into the various subsystems required to assemble a cloud and to find out how frustrating aspects of it could be. A cloud is a jigsaw, requiring many different pieces to fit together and co-operate. This talk will take a look at a number of Open Source technologies and how they fit into this puzzle: First you need a way to run Virtual Machines, this is probably the easiest part of the jigsaw. Next you need a way to store and distribute your Virtual Machine volumes. Ceph fits in here nicely. Then you need a way to connect all your Virtual Machines together. You could just use the Linux networking stack. Or you could look at VPP, an exciting userspace networking stack born out of Cisco. Great now your VMs can talk to each other and things, but how do you do that first boot configuration: well hello Cloud Init. Finally you need a way to push traffic to your VMs, enter HAProxy. Driven by curiosity and some late night ebay purchases, I ended up down the rabbit hole of building a cloud from scratch: why use OpenStack when you can do it the hard way. This was a great excuse to dive into the various subsystems required to assemble a cloud and to find out how frustrating aspects of it could be. A cloud is a jigsaw, requiring many different pieces to fit together and co-operate. This talk will take a look at a number of Open Source technologies and how they fit into this puzzle: First you need a way to run Virtual Machines, this is probably the easiest part of the jigsaw. Next you need a way to store and distribute your Virtual Machine volumes. Ceph fits in here nicely. Then you need a way to connect all your Virtual Machines together. You could just use the Linux networking stack. Or you could look at VPP, an exciting userspace networking stack born out of Cisco. Great now your VMs can talk to each other and things, but how do you do that first boot configuration: well hello Cloud Init. Finally you need a way to push traffic to your VMs, enter HAProxy. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1903-eng-Cloud_From_Scratch_hd.mp4?1527272602 M0UgqMLHs5WPCdozDdi7BQ 2018-05-25T00:00:00+02:00 Chris Ellis No osc18, 1903, Cloud and Containers Building a small cloud the hard way Driven by curiosity and some late night ebay purchases, I ended up down the rabbit hole of building a cloud from scratch: why use OpenStack when you can do it the hard way. This was a great excuse to dive into the various subsystems required to assemble a cloud and to find out how frustrating aspects of it could be. A cloud is a jigsaw, requiring many different pieces to fit together and co-operate. This talk will take a look at a number of Open Source technologies and how they fit into this puzzle: First you need a way to run Virtual Machines, this is probably the easiest part of the jigsaw. Next you need a way to store and distribute your Virtual Machine volumes. Ceph fits in here nicely. Then you need a way to connect all your Virtual Machines together. You could just use the Linux networking stack. Or you could look at VPP, an exciting userspace networking stack born out of Cisco. Great now your VMs can talk to each other and things, but how do you do that first boot configuration: well hello Cloud Init. Finally you need a way to push traffic to your VMs, enter HAProxy. Driven by curiosity and some late night ebay purchases, I ended up down the rabbit hole of building a cloud from scratch: why use OpenStack when you can do it the hard way. This was a great excuse to dive into the various subsystems required to assemble a cloud and to find out how frustrating aspects of it could be. A cloud is a jigsaw, requiring many different pieces to fit together and co-operate. This talk will take a look at a number of Open Source technologies and how they fit into this puzzle: First you need a way to run Virtual Machines, this is probably the easiest part of the jigsaw. Next you need a way to store and distribute your Virtual Machine volumes. Ceph fits in here nicely. Then you need a way to connect all your Virtual Machines together. You could just use the Linux networking stack. Or you could look at VPP, an exciting userspace networking stack born out of Cisco. Great now your VMs can talk to each other and things, but how do you do that first boot configuration: well hello Cloud Init. Finally you need a way to push traffic to your VMs, enter HAProxy. about this event: https://c3voc.de 00:42:02 https://media.ccc.de/v/1696-how-to-implement-a-new-l4-protocol-in-vpp VPP (Vector Packet Processing) is the opensource software aiming to very fast data-processing and its part of the umbrella project known as FD.io This talk describes how to design and integrate a new L4 protocol in the existing VPP (Vector Packet Processing) framework. We will use as an example the novel SCTP implementation which has been developed (and now maintained) by the SUSE employee Marco Varlese. We will go through the concept of the transport-layer and how the upper-layers (session and application) in VPP interact with the transport-layer in order to fully establish an SCTP connection, how to send and receive data and eventually terminate a connection. We will also showcase the new SCTP implementation and the diverse levels of debugging offered. VPP (Vector Packet Processing) is the opensource software aiming to very fast data-processing and its part of the umbrella project known as FD.io This talk describes how to design and integrate a new L4 protocol in the existing VPP (Vector Packet Processing) framework. We will use as an example the novel SCTP implementation which has been developed (and now maintained) by the SUSE employee Marco Varlese. We will go through the concept of the transport-layer and how the upper-layers (session and application) in VPP interact with the transport-layer in order to fully establish an SCTP connection, how to send and receive data and eventually terminate a connection. We will also showcase the new SCTP implementation and the diverse levels of debugging offered. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1696-eng-How_to_implement_a_new_L4_protocol_in_VPP_hd.mp4?1527272583 XCBMq_i8qHZWOd-VFz1i2w 2018-05-25T00:00:00+02:00 Marco Varlese No osc18, 1696, Open Source Design tips for success VPP (Vector Packet Processing) is the opensource software aiming to very fast data-processing and its part of the umbrella project known as FD.io This talk describes how to design and integrate a new L4 protocol in the existing VPP (Vector Packet Processing) framework. We will use as an example the novel SCTP implementation which has been developed (and now maintained) by the SUSE employee Marco Varlese. We will go through the concept of the transport-layer and how the upper-layers (session and application) in VPP interact with the transport-layer in order to fully establish an SCTP connection, how to send and receive data and eventually terminate a connection. We will also showcase the new SCTP implementation and the diverse levels of debugging offered. VPP (Vector Packet Processing) is the opensource software aiming to very fast data-processing and its part of the umbrella project known as FD.io This talk describes how to design and integrate a new L4 protocol in the existing VPP (Vector Packet Processing) framework. We will use as an example the novel SCTP implementation which has been developed (and now maintained) by the SUSE employee Marco Varlese. We will go through the concept of the transport-layer and how the upper-layers (session and application) in VPP interact with the transport-layer in order to fully establish an SCTP connection, how to send and receive data and eventually terminate a connection. We will also showcase the new SCTP implementation and the diverse levels of debugging offered. about this event: https://c3voc.de 00:40:25 https://media.ccc.de/v/1990-ceph-the-distributed-storage-solution You want to learn more about distributed storage solutions and in particular about Ceph? In this talk I would like to give you a quick introduction about distributed storage and Ceph at a glance. What is it? Why is it useful? Why do I need it? Isn't a single NAS system suffiecient? Who should join? Everyone who uses storage :-) What is Ceph? Ceph’s foundation is the Reliable Autonomic Distributed Object Store (RADOS), which provides your applications with object, block, and file system storage in a single unified storage cluster—making Ceph flexible, highly reliable and easy for you to manage. You want to learn more about distributed storage solutions and in particular about Ceph? In this talk I would like to give you a quick introduction about distributed storage and Ceph at a glance. What is it? Why is it useful? Why do I need it? Isn't a single NAS system suffiecient? Who should join? Everyone who uses storage :-) What is Ceph? Ceph’s foundation is the Reliable Autonomic Distributed Object Store (RADOS), which provides your applications with object, block, and file system storage in a single unified storage cluster—making Ceph flexible, highly reliable and easy for you to manage. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1990-eng-Ceph_-_The_Distributed_Storage_Solution_hd.mp4?1527272534 Wy6jqnZ_111KAk-Vr3FLXA 2018-05-25T00:00:00+02:00 Kai Wagner, Laura Paduano No osc18, 1990, Open Source Isn't a single NAS system sufficient? You want to learn more about distributed storage solutions and in particular about Ceph? In this talk I would like to give you a quick introduction about distributed storage and Ceph at a glance. What is it? Why is it useful? Why do I need it? Isn't a single NAS system suffiecient? Who should join? Everyone who uses storage :-) What is Ceph? Ceph’s foundation is the Reliable Autonomic Distributed Object Store (RADOS), which provides your applications with object, block, and file system storage in a single unified storage cluster—making Ceph flexible, highly reliable and easy for you to manage. You want to learn more about distributed storage solutions and in particular about Ceph? In this talk I would like to give you a quick introduction about distributed storage and Ceph at a glance. What is it? Why is it useful? Why do I need it? Isn't a single NAS system suffiecient? Who should join? Everyone who uses storage :-) What is Ceph? Ceph’s foundation is the Reliable Autonomic Distributed Object Store (RADOS), which provides your applications with object, block, and file system storage in a single unified storage cluster—making Ceph flexible, highly reliable and easy for you to manage. about this event: https://c3voc.de 00:30:23 https://media.ccc.de/v/1690-keep-calm-and-refactor-obs Open Build Service frontend was started in 2005, even before the first version of Rails was released.It is most likely one of the oldest Rails Project that people still keep using! That implies that legacy code and refactoring are two daily topics in all OBS developers’ lives. As said, OBS has already some years and because of that all kind of talks about it have been held: how to use it, its features, how will it look like in the features, statistic,... but nobody has ever spoken about how it is working in such a code. I will speak about how it was facing some OBS frontend code, what kind of code got refactored and what I learned while doing it. Open Build Service frontend was started in 2005, even before the first version of Rails was released.It is most likely one of the oldest Rails Project that people still keep using! That implies that legacy code and refactoring are two daily topics in all OBS developers’ lives. As said, OBS has already some years and because of that all kind of talks about it have been held: how to use it, its features, how will it look like in the features, statistic,... but nobody has ever spoken about how it is working in such a code. I will speak about how it was facing some OBS frontend code, what kind of code got refactored and what I learned while doing it. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1690-eng-Keep_calm_and_refactor_OBS_hd.mp4?1527272503 PSNj5CJgKM1WthKxWpfZ6g 2018-05-25T00:00:00+02:00 Ana Maria Martinez Gomez No osc18, 1690, Open Source What I learn while refactoring OBS Open Build Service frontend was started in 2005, even before the first version of Rails was released.It is most likely one of the oldest Rails Project that people still keep using! That implies that legacy code and refactoring are two daily topics in all OBS developers’ lives. As said, OBS has already some years and because of that all kind of talks about it have been held: how to use it, its features, how will it look like in the features, statistic,... but nobody has ever spoken about how it is working in such a code. I will speak about how it was facing some OBS frontend code, what kind of code got refactored and what I learned while doing it. Open Build Service frontend was started in 2005, even before the first version of Rails was released.It is most likely one of the oldest Rails Project that people still keep using! That implies that legacy code and refactoring are two daily topics in all OBS developers’ lives. As said, OBS has already some years and because of that all kind of talks about it have been held: how to use it, its features, how will it look like in the features, statistic,... but nobody has ever spoken about how it is working in such a code. I will speak about how it was facing some OBS frontend code, what kind of code got refactored and what I learned while doing it. about this event: https://c3voc.de 00:22:01 https://media.ccc.de/v/1678-create-a-complete-tor-onion-site-with-docker-and-opensuse-in-less-than-15-minutes In a way, both Docker and Tor are shrouded in mystery. Containers have been the biggest thing in the IT field in the past few years and yet a lot of people don't know what they are good for. Why not just use a VM? Likewise, Tor is known only for the negative uses and connotations such as "The Dark Web" and "The Deep Web" meanwhile not many people know about the actual positives of the technology when it comes to secure communication and privacy. My presentation would be a short primer on both of these technologies followed by a 15-minute demonstration on how to create a Wordpress website, MariaDB Database, and Tor entry point with Docker on OpenSUSE Leap 15 that can be recreated on any hardware or VM even without an external IP and accessed anywhere in the world using the Tor Browser. There should also be time to take Q&A at the end. My docker-compose files, notes, and presentation will then be available on GitHub. In a way, both Docker and Tor are shrouded in mystery. Containers have been the biggest thing in the IT field in the past few years and yet a lot of people don't know what they are good for. Why not just use a VM? Likewise, Tor is known only for the negative uses and connotations such as "The Dark Web" and "The Deep Web" meanwhile not many people know about the actual positives of the technology when it comes to secure communication and privacy. My presentation would be a short primer on both of these technologies followed by a 15-minute demonstration on how to create a Wordpress website, MariaDB Database, and Tor entry point with Docker on OpenSUSE Leap 15 that can be recreated on any hardware or VM even without an external IP and accessed anywhere in the world using the Tor Browser. There should also be time to take Q&A at the end. My docker-compose files, notes, and presentation will then be available on GitHub. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1678-eng-Create_a_complete_Tor_onion_site_with_Docker_and_OpenSUSE_in_less_than_15_minutes_hd.mp4?1527272472 lCd2eP4dZfnl5eXWz14qIQ 2018-05-25T00:00:00+02:00 jsevans No osc18, 1678, Cloud and Containers Doing something cool with minimum time. In a way, both Docker and Tor are shrouded in mystery. Containers have been the biggest thing in the IT field in the past few years and yet a lot of people don't know what they are good for. Why not just use a VM? Likewise, Tor is known only for the negative uses and connotations such as "The Dark Web" and "The Deep Web" meanwhile not many people know about the actual positives of the technology when it comes to secure communication and privacy. My presentation would be a short primer on both of these technologies followed by a 15-minute demonstration on how to create a Wordpress website, MariaDB Database, and Tor entry point with Docker on OpenSUSE Leap 15 that can be recreated on any hardware or VM even without an external IP and accessed anywhere in the world using the Tor Browser. There should also be time to take Q&A at the end. My docker-compose files, notes, and presentation will then be available on GitHub. In a way, both Docker and Tor are shrouded in mystery. Containers have been the biggest thing in the IT field in the past few years and yet a lot of people don't know what they are good for. Why not just use a VM? Likewise, Tor is known only for the negative uses and connotations such as "The Dark Web" and "The Deep Web" meanwhile not many people know about the actual positives of the technology when it comes to secure communication and privacy. My presentation would be a short primer on both of these technologies followed by a 15-minute demonstration on how to create a Wordpress website, MariaDB Database, and Tor entry point with Docker on OpenSUSE Leap 15 that can be recreated on any hardware or VM even without an external IP and accessed anywhere in the world using the Tor Browser. There should also be time to take Q&A at the end. My docker-compose files, notes, and presentation will then be available on GitHub. about this event: https://c3voc.de 00:21:29 https://media.ccc.de/v/1774-project-egkatastasis In Tumbleweed with have roughly ~25.000 packages for 64-bit architecture. Do you know how many of those are actually install-able? From those who are not, do you know the reason behind? Do you know how many of those will become install-able if boo#123456 gets fixed? And from those which can actually be installed, do you know if there are any glitches at the post-installation scripts? -Sure, we have openQA, but still, it tests only the packages inside the DVD and not the entire ecosystem. - Sure, we have the OBS. So, everything that gets build should also be install-able. No? -Sure, we have libsolv techniques that can answer this. But have you tested if the results reflect the real world? There's only way to do verify what's really happening: one system per package. Yes, that is extreme, you would probably need 25.000 virtual machines. But ... hold on... what about using containers? Well, I have an idea! I have developed a project for fun, and I would be delighted to share it with you. Egkatastasis (you can call it *egg*) is an open source system for testing openSUSE container images providing basic mechanisms for installation, log analysis, and metrics visualization of every package contained into the official repositories. Egkatastasis tests production container workloads at scale using Docker and systemd-nspawn, combined with the best-of-breed ideas and practices from the community using Filebeat and Elastic Stack. In Tumbleweed with have roughly ~25.000 packages for 64-bit architecture. Do you know how many of those are actually install-able? From those who are not, do you know the reason behind? Do you know how many of those will become install-able if boo#123456 gets fixed? And from those which can actually be installed, do you know if there are any glitches at the post-installation scripts? -Sure, we have openQA, but still, it tests only the packages inside the DVD and not the entire ecosystem. - Sure, we have the OBS. So, everything that gets build should also be install-able. No? -Sure, we have libsolv techniques that can answer this. But have you tested if the results reflect the real world? There's only way to do verify what's really happening: one system per package. Yes, that is extreme, you would probably need 25.000 virtual machines. But ... hold on... what about using containers? Well, I have an idea! I have developed a project for fun, and I would be delighted to share it with you. Egkatastasis (you can call it *egg*) is an open source system for testing openSUSE container images providing basic mechanisms for installation, log analysis, and metrics visualization of every package contained into the official repositories. Egkatastasis tests production container workloads at scale using Docker and systemd-nspawn, combined with the best-of-breed ideas and practices from the community using Filebeat and Elastic Stack. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1774-eng-Project_Egkatastasis_hd.mp4?1527272446 l8rsEk_Xh1bV4a02AfxXkQ 2018-05-25T00:00:00+02:00 Panos Georgiadis No osc18, 1774, Cloud and Containers Testing package installation using containers In Tumbleweed with have roughly ~25.000 packages for 64-bit architecture. Do you know how many of those are actually install-able? From those who are not, do you know the reason behind? Do you know how many of those will become install-able if boo#123456 gets fixed? And from those which can actually be installed, do you know if there are any glitches at the post-installation scripts? -Sure, we have openQA, but still, it tests only the packages inside the DVD and not the entire ecosystem. - Sure, we have the OBS. So, everything that gets build should also be install-able. No? -Sure, we have libsolv techniques that can answer this. But have you tested if the results reflect the real world? There's only way to do verify what's really happening: one system per package. Yes, that is extreme, you would probably need 25.000 virtual machines. But ... hold on... what about using containers? Well, I have an idea! I have developed a project for fun, and I would be delighted to share it with you. Egkatastasis (you can call it *egg*) is an open source system for testing openSUSE container images providing basic mechanisms for installation, log analysis, and metrics visualization of every package contained into the official repositories. Egkatastasis tests production container workloads at scale using Docker and systemd-nspawn, combined with the best-of-breed ideas and practices from the community using Filebeat and Elastic Stack. In Tumbleweed with have roughly ~25.000 packages for 64-bit architecture. Do you know how many of those are actually install-able? From those who are not, do you know the reason behind? Do you know how many of those will become install-able if boo#123456 gets fixed? And from those which can actually be installed, do you know if there are any glitches at the post-installation scripts? -Sure, we have openQA, but still, it tests only the packages inside the DVD and not the entire ecosystem. - Sure, we have the OBS. So, everything that gets build should also be install-able. No? -Sure, we have libsolv techniques that can answer this. But have you tested if the results reflect the real world? There's only way to do verify what's really happening: one system per package. Yes, that is extreme, you would probably need 25.000 virtual machines. But ... hold on... what about using containers? Well, I have an idea! I have developed a project for fun, and I would be delighted to share it with you. Egkatastasis (you can call it *egg*) is an open source system for testing openSUSE container images providing basic mechanisms for installation, log analysis, and metrics visualization of every package contained into the official repositories. Egkatastasis tests production container workloads at scale using Docker and systemd-nspawn, combined with the best-of-breed ideas and practices from the community using Filebeat and Elastic Stack. about this event: https://c3voc.de 00:30:25 https://media.ccc.de/v/1855-heroes-not-superheroes The Heroes were founded two years ago. In this time, we worked hard to maintain and enhance the openSUSE infrastructure, but talking about that would be boring. Of course, if you do a lot of things, you'll sometimes also make mistakes. Have a lot of fun with some of our failures, what we learned from them and where we still have room for improvement. The Heroes were founded two years ago. In this time, we worked hard to maintain and enhance the openSUSE infrastructure, but talking about that would be boring. Of course, if you do a lot of things, you'll sometimes also make mistakes. Have a lot of fun with some of our failures, what we learned from them and where we still have room for improvement. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1855-eng-Heroes_not_Superheroes_hd.mp4?1527272398 SVOFTyf_dWfQMYprqmk4tw 2018-05-25T00:00:00+02:00 Christian Boltz No osc18, 1855, openSUSE What the Heroes would prefer not to tell you ;-) The Heroes were founded two years ago. In this time, we worked hard to maintain and enhance the openSUSE infrastructure, but talking about that would be boring. Of course, if you do a lot of things, you'll sometimes also make mistakes. Have a lot of fun with some of our failures, what we learned from them and where we still have room for improvement. The Heroes were founded two years ago. In this time, we worked hard to maintain and enhance the openSUSE infrastructure, but talking about that would be boring. Of course, if you do a lot of things, you'll sometimes also make mistakes. Have a lot of fun with some of our failures, what we learned from them and where we still have room for improvement. about this event: https://c3voc.de 00:27:13 https://media.ccc.de/v/1753-let-s-talk-about-testing-software-and-user-experience-in-open-source Very often we come across a masterpiece of software, while now days almost everything is cool and built for the web, or built with technologies that are changing every single day and moving forward, but often we forget how the user feels when new software is available to download and install, it can be an overwhelming experience. This talk is meant to talk about how some projects show the true meaning of a Venn diagrams and offering a bit of guidance on how to make testing and user experience even better for your own project. Very often we come across a masterpiece of software, while now days almost everything is cool and built for the web, or built with technologies that are changing every single day and moving forward, but often we forget how the user feels when new software is available to download and install, it can be an overwhelming experience. This talk is meant to talk about how some projects show the true meaning of a Venn diagrams and offering a bit of guidance on how to make testing and user experience even better for your own project. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1753-eng-Lets_talk_about_testing_software_and_user_experience_in_open_source_hd.mp4?1527272364 XVN0_UnceB4XJtwpvUyHeA 2018-05-25T00:00:00+02:00 Santiago Zarate No osc18, 1753, Open Source Very often we come across a masterpiece of software, while now days almost everything is cool and built for the web, or built with technologies that are changing every single day and moving forward, but often we forget how the user feels when new software is available to download and install, it can be an overwhelming experience. This talk is meant to talk about how some projects show the true meaning of a Venn diagrams and offering a bit of guidance on how to make testing and user experience even better for your own project. Very often we come across a masterpiece of software, while now days almost everything is cool and built for the web, or built with technologies that are changing every single day and moving forward, but often we forget how the user feels when new software is available to download and install, it can be an overwhelming experience. This talk is meant to talk about how some projects show the true meaning of a Venn diagrams and offering a bit of guidance on how to make testing and user experience even better for your own project. about this event: https://c3voc.de 00:28:38 https://media.ccc.de/v/1681-openfaas A quick introduction to the concept of a Serverless and Function-as-a-Service followed by a live demo session based on the SUSE Container-as-a-Service-Plarform (CaaSP v2.0). The presenter will cover the following topics: - What is Serverless and OpenFaaS - Use Helm to setup OpenFaaS in SUSE CaaSP and/or test it using DockerSwarm - Create your own openFaaS openSUSE Docker image in DockerHub - Try out a couple of examples presented earlier at DockerCon17 (Copenhagen) - Horizontal auto-scaling on demand and monitoring with Prometheus - How to create your own functions Note: For all of you who are not yet exposed to the power of containers, we will not be liable for any crazy ideas that you will be interested in applying to production after this awesome experience. A quick introduction to the concept of a Serverless and Function-as-a-Service followed by a live demo session based on the SUSE Container-as-a-Service-Plarform (CaaSP v2.0). The presenter will cover the following topics: - What is Serverless and OpenFaaS - Use Helm to setup OpenFaaS in SUSE CaaSP and/or test it using DockerSwarm - Create your own openFaaS openSUSE Docker image in DockerHub - Try out a couple of examples presented earlier at DockerCon17 (Copenhagen) - Horizontal auto-scaling on demand and monitoring with Prometheus - How to create your own functions Note: For all of you who are not yet exposed to the power of containers, we will not be liable for any crazy ideas that you will be interested in applying to production after this awesome experience. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1681-eng-OpenFaaS_hd.mp4?1527272336 cvUKm9p3vQyIhlh5sgX0uA 2018-05-25T00:00:00+02:00 Panos Georgiadis No osc18, 1681, Cloud and Containers Serveless Framework for Docker/OCI and Kubernetes A quick introduction to the concept of a Serverless and Function-as-a-Service followed by a live demo session based on the SUSE Container-as-a-Service-Plarform (CaaSP v2.0). The presenter will cover the following topics: - What is Serverless and OpenFaaS - Use Helm to setup OpenFaaS in SUSE CaaSP and/or test it using DockerSwarm - Create your own openFaaS openSUSE Docker image in DockerHub - Try out a couple of examples presented earlier at DockerCon17 (Copenhagen) - Horizontal auto-scaling on demand and monitoring with Prometheus - How to create your own functions Note: For all of you who are not yet exposed to the power of containers, we will not be liable for any crazy ideas that you will be interested in applying to production after this awesome experience. A quick introduction to the concept of a Serverless and Function-as-a-Service followed by a live demo session based on the SUSE Container-as-a-Service-Plarform (CaaSP v2.0). The presenter will cover the following topics: - What is Serverless and OpenFaaS - Use Helm to setup OpenFaaS in SUSE CaaSP and/or test it using DockerSwarm - Create your own openFaaS openSUSE Docker image in DockerHub - Try out a couple of examples presented earlier at DockerCon17 (Copenhagen) - Horizontal auto-scaling on demand and monitoring with Prometheus - How to create your own functions Note: For all of you who are not yet exposed to the power of containers, we will not be liable for any crazy ideas that you will be interested in applying to production after this awesome experience. about this event: https://c3voc.de 00:47:18 https://media.ccc.de/v/2011-keynote-for-osc-2018 Keynote for openSUSE Conference 2018 Keynote for openSUSE Conference 2018 about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-2011-eng-Keynote_for_oSC_2018_hd.mp4?1527272265 XYM8x8X3E5xUNIem0wVJaw 2018-05-25T00:00:00+02:00 Vojtěch Pavlík No osc18, 2011, openSUSE Keynote for openSUSE Conference 2018 Keynote for openSUSE Conference 2018 about this event: https://c3voc.de 00:21:34 https://media.ccc.de/v/1867-svg-as-the-single-source-of-truth SVG is magical when you think about it. It's one of the few formats both developers and designers can interact with. With the rise of SVG compatibility on the web, the format has enjoyed various new use cases with the HTML5 specification. Could it be used as a common file format both designers and developers can collaborate together? As SVG is basically just lines of code, shouldn't designers benefit from this vizualised version control without going through the painful git learning process? SVG could be the meeting point for version control powered by git, both suitable for developers but also designers. Let's talk about how this could look like with Free Open Source Software like Identihub, a potential frontend for version controlling visual assets in the future. SVG is magical when you think about it. It's one of the few formats both developers and designers can interact with. With the rise of SVG compatibility on the web, the format has enjoyed various new use cases with the HTML5 specification. Could it be used as a common file format both designers and developers can collaborate together? As SVG is basically just lines of code, shouldn't designers benefit from this vizualised version control without going through the painful git learning process? SVG could be the meeting point for version control powered by git, both suitable for developers but also designers. Let's talk about how this could look like with Free Open Source Software like Identihub, a potential frontend for version controlling visual assets in the future. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1867-eng-SVG_as_the_single_source_of_truth_hd.mp4?1527272243 YEJOkxvQJMR7HSFH9bSSNA 2018-05-25T00:00:00+02:00 Elio Qoshi No osc18, 1867, Open Source The designer version control of the future? SVG is magical when you think about it. It's one of the few formats both developers and designers can interact with. With the rise of SVG compatibility on the web, the format has enjoyed various new use cases with the HTML5 specification. Could it be used as a common file format both designers and developers can collaborate together? As SVG is basically just lines of code, shouldn't designers benefit from this vizualised version control without going through the painful git learning process? SVG could be the meeting point for version control powered by git, both suitable for developers but also designers. Let's talk about how this could look like with Free Open Source Software like Identihub, a potential frontend for version controlling visual assets in the future. SVG is magical when you think about it. It's one of the few formats both developers and designers can interact with. With the rise of SVG compatibility on the web, the format has enjoyed various new use cases with the HTML5 specification. Could it be used as a common file format both designers and developers can collaborate together? As SVG is basically just lines of code, shouldn't designers benefit from this vizualised version control without going through the painful git learning process? SVG could be the meeting point for version control powered by git, both suitable for developers but also designers. Let's talk about how this could look like with Free Open Source Software like Identihub, a potential frontend for version controlling visual assets in the future. about this event: https://c3voc.de 00:13:55 https://media.ccc.de/v/1744-why-opensuse This talks is split in three topics: 1. openSUSE is not SUSE, it is her sister. There are still too much people outside of open/SUSE world that still confuse the difference and the options they have. This usually leads them to use the wrong distribution for their use cases and thinking that "SUSE" is not working for them. I will describe the current distribution palette and their respective key values and the difference from the SUSE company and openSUSE community. 2. Why should I use openSUSE? I will describe which features from openSUSE make it ideal for which use case. A brief description of what I personally name the gold triangle of openSUSE is mandatory (OBS, openQA, Yast). 3. How to contribute to openSUSE I will describe the workflow to contribute to openSUSE, new packages and maintenance, and how OBS and openQA are involved. This talks is split in three topics: 1. openSUSE is not SUSE, it is her sister. There are still too much people outside of open/SUSE world that still confuse the difference and the options they have. This usually leads them to use the wrong distribution for their use cases and thinking that "SUSE" is not working for them. I will describe the current distribution palette and their respective key values and the difference from the SUSE company and openSUSE community. 2. Why should I use openSUSE? I will describe which features from openSUSE make it ideal for which use case. A brief description of what I personally name the gold triangle of openSUSE is mandatory (OBS, openQA, Yast). 3. How to contribute to openSUSE I will describe the workflow to contribute to openSUSE, new packages and maintenance, and how OBS and openQA are involved. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1744-eng-Why_openSUSE_hd.mp4?1527272204 BYAPpSpdg3PEN4qfQS7BlQ 2018-05-25T00:00:00+02:00 SLindoMansilla No osc18, 1744, openSUSE About ideal use case and promoting the gold triangle of openSUSE This talks is split in three topics: 1. openSUSE is not SUSE, it is her sister. There are still too much people outside of open/SUSE world that still confuse the difference and the options they have. This usually leads them to use the wrong distribution for their use cases and thinking that "SUSE" is not working for them. I will describe the current distribution palette and their respective key values and the difference from the SUSE company and openSUSE community. 2. Why should I use openSUSE? I will describe which features from openSUSE make it ideal for which use case. A brief description of what I personally name the gold triangle of openSUSE is mandatory (OBS, openQA, Yast). 3. How to contribute to openSUSE I will describe the workflow to contribute to openSUSE, new packages and maintenance, and how OBS and openQA are involved. This talks is split in three topics: 1. openSUSE is not SUSE, it is her sister. There are still too much people outside of open/SUSE world that still confuse the difference and the options they have. This usually leads them to use the wrong distribution for their use cases and thinking that "SUSE" is not working for them. I will describe the current distribution palette and their respective key values and the difference from the SUSE company and openSUSE community. 2. Why should I use openSUSE? I will describe which features from openSUSE make it ideal for which use case. A brief description of what I personally name the gold triangle of openSUSE is mandatory (OBS, openQA, Yast). 3. How to contribute to openSUSE I will describe the workflow to contribute to openSUSE, new packages and maintenance, and how OBS and openQA are involved. about this event: https://c3voc.de 00:24:40 https://media.ccc.de/v/1822-repository-priorities-for-the-real-world-user The topic of additional repositories comes up on a regular basis. The official position is to submit everything to Factory to avoid the issue, but for a large number of reasons this cannot always be the case. As such users living in the real world have to navigate the unsupported landscape. By far the best approach is to use repository priorities available through libzypp, but unfortunately this is not well known. This quick talk will cover the basic usage of priorities, strategies for real usage, and examples of how effective the workflow can be. Additionally some pitfalls will also be covered. The topic of additional repositories comes up on a regular basis. The official position is to submit everything to Factory to avoid the issue, but for a large number of reasons this cannot always be the case. As such users living in the real world have to navigate the unsupported landscape. By far the best approach is to use repository priorities available through libzypp, but unfortunately this is not well known. This quick talk will cover the basic usage of priorities, strategies for real usage, and examples of how effective the workflow can be. Additionally some pitfalls will also be covered. about this event: https://c3voc.de Fri, 25 May 2018 00:00:00 +0200 https://cdn.media.ccc.de/events/osc/2018/h264-hd/osc18-1822-eng-Repository_priorities_for_the_real_world_user_hd.mp4?1527272148 z6qh-Z9MFifDpoSQt8NQAg 2018-05-25T00:00:00+02:00 Jimmy Berry No osc18, 1822, openSUSE Use additional repositories with confidence The topic of additional repositories comes up on a regular basis. The official position is to submit everything to Factory to avoid the issue, but for a large number of reasons this cannot always be the case. As such users living in the real world have to navigate the unsupported landscape. By far the best approach is to use repository priorities available through libzypp, but unfortunately this is not well known. This quick talk will cover the basic usage of priorities, strategies for real usage, and examples of how effective the workflow can be. Additionally some pitfalls will also be covered. The topic of additional repositories comes up on a regular basis. The official position is to submit everything to Factory to avoid the issue, but for a large number of reasons this cannot always be the case. As such users living in the real world have to navigate the unsupported landscape. By far the best approach is to use repository priorities available through libzypp, but unfortunately this is not well known. This quick talk will cover the basic usage of priorities, strategies for real usage, and examples of how effective the workflow can be. Additionally some pitfalls will also be covered. about this event: https://c3voc.de 00:11:10 media.ccc.de / RSS 0.3.1 CCC media team media@c3voc.de CCC media team No CCC Congress Hacking Security Netzpolitik A wide variety of video material distributed by the CCC. All content is taken from cdn.media.ccc.de and media.ccc.de A wide variety of video material distributed by the Chaos Computer Club. This feed contains all events from osc18 as mp4